diff --git a/build.rs b/build.rs new file mode 100644 index 0000000000000000000000000000000000000000..597923f508921809ff9e8563158f5f94b3713a66 --- /dev/null +++ b/build.rs @@ -0,0 +1,16 @@ +use std::env; +use std::fs::File; +use std::io::Write; +use std::path::PathBuf; +fn main() { + if env::var_os("CARGO_FEATURE_RT").is_some() { + let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap()); + File::create(out.join("device.x")) + .unwrap() + .write_all(include_bytes!("device.x")) + .unwrap(); + println!("cargo:rustc-link-search={}", out.display()); + println!("cargo:rerun-if-changed=device.x"); + } + println!("cargo:rerun-if-changed=build.rs"); +} diff --git a/device.x b/device.x new file mode 100644 index 0000000000000000000000000000000000000000..731d59c384bdb0d15ff519f28077d2a68a398c8d --- /dev/null +++ b/device.x @@ -0,0 +1,97 @@ +PROVIDE(WWDG = DefaultHandler); +PROVIDE(PVD = DefaultHandler); +PROVIDE(TAMP_STAMP = DefaultHandler); +PROVIDE(RTC_WKUP = DefaultHandler); +PROVIDE(FLASH = DefaultHandler); +PROVIDE(RCC = DefaultHandler); +PROVIDE(EXTI0 = DefaultHandler); +PROVIDE(EXTI1 = DefaultHandler); +PROVIDE(EXTI2 = DefaultHandler); +PROVIDE(EXTI3 = DefaultHandler); +PROVIDE(EXTI4 = DefaultHandler); +PROVIDE(DMA1_STREAM0 = DefaultHandler); +PROVIDE(DMA1_STREAM1 = DefaultHandler); +PROVIDE(DMA1_STREAM2 = DefaultHandler); +PROVIDE(DMA1_STREAM3 = DefaultHandler); +PROVIDE(DMA1_STREAM4 = DefaultHandler); +PROVIDE(DMA1_STREAM5 = DefaultHandler); +PROVIDE(DMA1_STREAM6 = DefaultHandler); +PROVIDE(ADC = DefaultHandler); +PROVIDE(CAN1_TX = DefaultHandler); +PROVIDE(CAN1_RX0 = DefaultHandler); +PROVIDE(CAN1_RX1 = DefaultHandler); +PROVIDE(CAN1_SCE = DefaultHandler); +PROVIDE(EXTI9_5 = DefaultHandler); +PROVIDE(TIM1_BRK_TIM9 = DefaultHandler); +PROVIDE(TIM1_UP_TIM10 = DefaultHandler); +PROVIDE(TIM1_TRG_COM_TIM11 = DefaultHandler); +PROVIDE(TIM1_CC = DefaultHandler); +PROVIDE(TIM2 = DefaultHandler); +PROVIDE(TIM3 = DefaultHandler); +PROVIDE(TIM4 = DefaultHandler); +PROVIDE(I2C1_EVT = DefaultHandler); +PROVIDE(I2C1_ERR = DefaultHandler); +PROVIDE(I2C2_EVT = DefaultHandler); +PROVIDE(I2C2_ERR = DefaultHandler); +PROVIDE(SPI1 = DefaultHandler); +PROVIDE(SPI2 = DefaultHandler); +PROVIDE(USART1 = DefaultHandler); +PROVIDE(USART2 = DefaultHandler); +PROVIDE(USART3 = DefaultHandler); +PROVIDE(EXTI15_10 = DefaultHandler); +PROVIDE(EXTI17_RTC_ALARM = DefaultHandler); +PROVIDE(EXTI18_OTG_FS_WKUP = DefaultHandler); +PROVIDE(TIM8_BRK_TIM12 = DefaultHandler); +PROVIDE(TIM8_UP_TIM13 = DefaultHandler); +PROVIDE(TIM8_TRG_COM_TIM14 = DefaultHandler); +PROVIDE(TIM8_CC = DefaultHandler); +PROVIDE(DMA1_STREAM7 = DefaultHandler); +PROVIDE(FSMC = DefaultHandler); +PROVIDE(SDIO = DefaultHandler); +PROVIDE(TIM5 = DefaultHandler); +PROVIDE(SPI3 = DefaultHandler); +PROVIDE(USART4 = DefaultHandler); +PROVIDE(UART5 = DefaultHandler); +PROVIDE(TIM6_GLB_IT_DAC1_DAC2 = DefaultHandler); +PROVIDE(TIM7 = DefaultHandler); +PROVIDE(DMA2_STREAM0 = DefaultHandler); +PROVIDE(DMA2_STREAM1 = DefaultHandler); +PROVIDE(DMA2_STREAM2 = DefaultHandler); +PROVIDE(DMA2_STREAM3 = DefaultHandler); +PROVIDE(DMA2_STREAM4 = DefaultHandler); +PROVIDE(DFSDM1_FLT0 = DefaultHandler); +PROVIDE(DFSDM1_FLT1 = DefaultHandler); +PROVIDE(CAN2_TX = DefaultHandler); +PROVIDE(CAN2_RX0 = DefaultHandler); +PROVIDE(CAN2_RX1 = DefaultHandler); +PROVIDE(CAN2_SCE = DefaultHandler); +PROVIDE(OTG_FS_USB = DefaultHandler); +PROVIDE(DMA2_STREAM5 = DefaultHandler); +PROVIDE(DMA2_STREAM6 = DefaultHandler); +PROVIDE(DMA2_STREAM7 = DefaultHandler); +PROVIDE(USART6 = DefaultHandler); +PROVIDE(I2C3_EV = DefaultHandler); +PROVIDE(I2C3_ER = DefaultHandler); +PROVIDE(CAN3_TX = DefaultHandler); +PROVIDE(CAN3_RX0 = DefaultHandler); +PROVIDE(CAN3_RX1 = DefaultHandler); +PROVIDE(CAN3_SCE = DefaultHandler); +PROVIDE(CRYPTO = DefaultHandler); +PROVIDE(RNG = DefaultHandler); +PROVIDE(FPU = DefaultHandler); +PROVIDE(USART7 = DefaultHandler); +PROVIDE(USART8 = DefaultHandler); +PROVIDE(SPI4 = DefaultHandler); +PROVIDE(SPI5 = DefaultHandler); +PROVIDE(SAI1 = DefaultHandler); +PROVIDE(UART9 = DefaultHandler); +PROVIDE(UART10 = DefaultHandler); +PROVIDE(QUADSPI = DefaultHandler); +PROVIDE(I2CFMP1EVENT = DefaultHandler); +PROVIDE(I2CFMP1ERROR = DefaultHandler); +PROVIDE(LPTIM1_OR_IT_EIT_23 = DefaultHandler); +PROVIDE(DFSDM2_FILTER1 = DefaultHandler); +PROVIDE(DFSDM2_FILTER2 = DefaultHandler); +PROVIDE(DFSDM2_FILTER3 = DefaultHandler); +PROVIDE(DFSDM2_FILTER4 = DefaultHandler); + diff --git a/src/adc1/ccr/mod.rs b/src/adc1/ccr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2e7b428150ce9cad27df61361edf2f356be4a004 --- /dev/null +++ b/src/adc1/ccr/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ADCPRER { + bits: u8, +} +impl ADCPRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct VBATER { + bits: bool, +} +impl VBATER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSVREFER { + bits: bool, +} +impl TSVREFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ADCPREW<'a> { + w: &'a mut W, +} +impl<'a> _ADCPREW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _VBATEW<'a> { + w: &'a mut W, +} +impl<'a> _VBATEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSVREFEW<'a> { + w: &'a mut W, +} +impl<'a> _TSVREFEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:17 - ADC prescaler"] + #[inline] + pub fn adcpre(&self) -> ADCPRER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADCPRER { bits } + } + #[doc = "Bit 22 - VBAT enable"] + #[inline] + pub fn vbate(&self) -> VBATER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + VBATER { bits } + } + #[doc = "Bit 23 - Temperature sensor and VREFINT enable"] + #[inline] + pub fn tsvrefe(&self) -> TSVREFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSVREFER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:17 - ADC prescaler"] + #[inline] + pub fn adcpre(&mut self) -> _ADCPREW { + _ADCPREW { w: self } + } + #[doc = "Bit 22 - VBAT enable"] + #[inline] + pub fn vbate(&mut self) -> _VBATEW { + _VBATEW { w: self } + } + #[doc = "Bit 23 - Temperature sensor and VREFINT enable"] + #[inline] + pub fn tsvrefe(&mut self) -> _TSVREFEW { + _TSVREFEW { w: self } + } +} diff --git a/src/adc1/cr1/mod.rs b/src/adc1/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3c8b302e3885972bd99748a2161645158e89c0b1 --- /dev/null +++ b/src/adc1/cr1/mod.rs @@ -0,0 +1,836 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OVRIER { + bits: bool, +} +impl OVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RESR { + bits: u8, +} +impl RESR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWDENR { + bits: bool, +} +impl AWDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JAWDENR { + bits: bool, +} +impl JAWDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DISCNUMR { + bits: u8, +} +impl DISCNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDISCENR { + bits: bool, +} +impl JDISCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DISCENR { + bits: bool, +} +impl DISCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JAUTOR { + bits: bool, +} +impl JAUTOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDSGLR { + bits: bool, +} +impl AWDSGLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCANR { + bits: bool, +} +impl SCANR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCIER { + bits: bool, +} +impl JEOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDIER { + bits: bool, +} +impl AWDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOCIER { + bits: bool, +} +impl EOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDCHR { + bits: u8, +} +impl AWDCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _OVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RESW<'a> { + w: &'a mut W, +} +impl<'a> _RESW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDENW<'a> { + w: &'a mut W, +} +impl<'a> _AWDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JAWDENW<'a> { + w: &'a mut W, +} +impl<'a> _JAWDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DISCNUMW<'a> { + w: &'a mut W, +} +impl<'a> _DISCNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JDISCENW<'a> { + w: &'a mut W, +} +impl<'a> _JDISCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DISCENW<'a> { + w: &'a mut W, +} +impl<'a> _DISCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JAUTOW<'a> { + w: &'a mut W, +} +impl<'a> _JAUTOW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDSGLW<'a> { + w: &'a mut W, +} +impl<'a> _AWDSGLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCANW<'a> { + w: &'a mut W, +} +impl<'a> _SCANW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDIEW<'a> { + w: &'a mut W, +} +impl<'a> _AWDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _EOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDCHW<'a> { + w: &'a mut W, +} +impl<'a> _AWDCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 26 - Overrun interrupt enable"] + #[inline] + pub fn ovrie(&self) -> OVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRIER { bits } + } + #[doc = "Bits 24:25 - Resolution"] + #[inline] + pub fn res(&self) -> RESR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RESR { bits } + } + #[doc = "Bit 23 - Analog watchdog enable on regular channels"] + #[inline] + pub fn awden(&self) -> AWDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDENR { bits } + } + #[doc = "Bit 22 - Analog watchdog enable on injected channels"] + #[inline] + pub fn jawden(&self) -> JAWDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JAWDENR { bits } + } + #[doc = "Bits 13:15 - Discontinuous mode channel count"] + #[inline] + pub fn discnum(&self) -> DISCNUMR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DISCNUMR { bits } + } + #[doc = "Bit 12 - Discontinuous mode on injected channels"] + #[inline] + pub fn jdiscen(&self) -> JDISCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JDISCENR { bits } + } + #[doc = "Bit 11 - Discontinuous mode on regular channels"] + #[inline] + pub fn discen(&self) -> DISCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DISCENR { bits } + } + #[doc = "Bit 10 - Automatic injected group conversion"] + #[inline] + pub fn jauto(&self) -> JAUTOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JAUTOR { bits } + } + #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"] + #[inline] + pub fn awdsgl(&self) -> AWDSGLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDSGLR { bits } + } + #[doc = "Bit 8 - Scan mode"] + #[inline] + pub fn scan(&self) -> SCANR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCANR { bits } + } + #[doc = "Bit 7 - Interrupt enable for injected channels"] + #[inline] + pub fn jeocie(&self) -> JEOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCIER { bits } + } + #[doc = "Bit 6 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&self) -> AWDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDIER { bits } + } + #[doc = "Bit 5 - Interrupt enable for EOC"] + #[inline] + pub fn eocie(&self) -> EOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOCIER { bits } + } + #[doc = "Bits 0:4 - Analog watchdog channel select bits"] + #[inline] + pub fn awdch(&self) -> AWDCHR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWDCHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 26 - Overrun interrupt enable"] + #[inline] + pub fn ovrie(&mut self) -> _OVRIEW { + _OVRIEW { w: self } + } + #[doc = "Bits 24:25 - Resolution"] + #[inline] + pub fn res(&mut self) -> _RESW { + _RESW { w: self } + } + #[doc = "Bit 23 - Analog watchdog enable on regular channels"] + #[inline] + pub fn awden(&mut self) -> _AWDENW { + _AWDENW { w: self } + } + #[doc = "Bit 22 - Analog watchdog enable on injected channels"] + #[inline] + pub fn jawden(&mut self) -> _JAWDENW { + _JAWDENW { w: self } + } + #[doc = "Bits 13:15 - Discontinuous mode channel count"] + #[inline] + pub fn discnum(&mut self) -> _DISCNUMW { + _DISCNUMW { w: self } + } + #[doc = "Bit 12 - Discontinuous mode on injected channels"] + #[inline] + pub fn jdiscen(&mut self) -> _JDISCENW { + _JDISCENW { w: self } + } + #[doc = "Bit 11 - Discontinuous mode on regular channels"] + #[inline] + pub fn discen(&mut self) -> _DISCENW { + _DISCENW { w: self } + } + #[doc = "Bit 10 - Automatic injected group conversion"] + #[inline] + pub fn jauto(&mut self) -> _JAUTOW { + _JAUTOW { w: self } + } + #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"] + #[inline] + pub fn awdsgl(&mut self) -> _AWDSGLW { + _AWDSGLW { w: self } + } + #[doc = "Bit 8 - Scan mode"] + #[inline] + pub fn scan(&mut self) -> _SCANW { + _SCANW { w: self } + } + #[doc = "Bit 7 - Interrupt enable for injected channels"] + #[inline] + pub fn jeocie(&mut self) -> _JEOCIEW { + _JEOCIEW { w: self } + } + #[doc = "Bit 6 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&mut self) -> _AWDIEW { + _AWDIEW { w: self } + } + #[doc = "Bit 5 - Interrupt enable for EOC"] + #[inline] + pub fn eocie(&mut self) -> _EOCIEW { + _EOCIEW { w: self } + } + #[doc = "Bits 0:4 - Analog watchdog channel select bits"] + #[inline] + pub fn awdch(&mut self) -> _AWDCHW { + _AWDCHW { w: self } + } +} diff --git a/src/adc1/cr2/mod.rs b/src/adc1/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9153c9775954a591df21d2b2faec839b4165e54f --- /dev/null +++ b/src/adc1/cr2/mod.rs @@ -0,0 +1,700 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SWSTARTR { + bits: bool, +} +impl SWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTENR { + bits: u8, +} +impl EXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTSELR { + bits: u8, +} +impl EXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JSWSTARTR { + bits: bool, +} +impl JSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEXTENR { + bits: u8, +} +impl JEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JEXTSELR { + bits: u8, +} +impl JEXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ALIGNR { + bits: bool, +} +impl ALIGNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOCSR { + bits: bool, +} +impl EOCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DDSR { + bits: bool, +} +impl DDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAR { + bits: bool, +} +impl DMAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CONTR { + bits: bool, +} +impl CONTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADONR { + bits: bool, +} +impl ADONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _SWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTENW<'a> { + w: &'a mut W, +} +impl<'a> _EXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _EXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _JSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALIGNW<'a> { + w: &'a mut W, +} +impl<'a> _ALIGNW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOCSW<'a> { + w: &'a mut W, +} +impl<'a> _EOCSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DDSW<'a> { + w: &'a mut W, +} +impl<'a> _DDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAW<'a> { + w: &'a mut W, +} +impl<'a> _DMAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CONTW<'a> { + w: &'a mut W, +} +impl<'a> _CONTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADONW<'a> { + w: &'a mut W, +} +impl<'a> _ADONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - Start conversion of regular channels"] + #[inline] + pub fn swstart(&self) -> SWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWSTARTR { bits } + } + #[doc = "Bits 28:29 - External trigger enable for regular channels"] + #[inline] + pub fn exten(&self) -> EXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTENR { bits } + } + #[doc = "Bits 24:27 - External event select for regular group"] + #[inline] + pub fn extsel(&self) -> EXTSELR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTSELR { bits } + } + #[doc = "Bit 22 - Start conversion of injected channels"] + #[inline] + pub fn jswstart(&self) -> JSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSWSTARTR { bits } + } + #[doc = "Bits 20:21 - External trigger enable for injected channels"] + #[inline] + pub fn jexten(&self) -> JEXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTENR { bits } + } + #[doc = "Bits 16:19 - External event select for injected group"] + #[inline] + pub fn jextsel(&self) -> JEXTSELR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTSELR { bits } + } + #[doc = "Bit 11 - Data alignment"] + #[inline] + pub fn align(&self) -> ALIGNR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALIGNR { bits } + } + #[doc = "Bit 10 - End of conversion selection"] + #[inline] + pub fn eocs(&self) -> EOCSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOCSR { bits } + } + #[doc = "Bit 9 - DMA disable selection (for single ADC mode)"] + #[inline] + pub fn dds(&self) -> DDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DDSR { bits } + } + #[doc = "Bit 8 - Direct memory access mode (for single ADC mode)"] + #[inline] + pub fn dma(&self) -> DMAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAR { bits } + } + #[doc = "Bit 1 - Continuous conversion"] + #[inline] + pub fn cont(&self) -> CONTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CONTR { bits } + } + #[doc = "Bit 0 - A/D Converter ON / OFF"] + #[inline] + pub fn adon(&self) -> ADONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADONR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 30 - Start conversion of regular channels"] + #[inline] + pub fn swstart(&mut self) -> _SWSTARTW { + _SWSTARTW { w: self } + } + #[doc = "Bits 28:29 - External trigger enable for regular channels"] + #[inline] + pub fn exten(&mut self) -> _EXTENW { + _EXTENW { w: self } + } + #[doc = "Bits 24:27 - External event select for regular group"] + #[inline] + pub fn extsel(&mut self) -> _EXTSELW { + _EXTSELW { w: self } + } + #[doc = "Bit 22 - Start conversion of injected channels"] + #[inline] + pub fn jswstart(&mut self) -> _JSWSTARTW { + _JSWSTARTW { w: self } + } + #[doc = "Bits 20:21 - External trigger enable for injected channels"] + #[inline] + pub fn jexten(&mut self) -> _JEXTENW { + _JEXTENW { w: self } + } + #[doc = "Bits 16:19 - External event select for injected group"] + #[inline] + pub fn jextsel(&mut self) -> _JEXTSELW { + _JEXTSELW { w: self } + } + #[doc = "Bit 11 - Data alignment"] + #[inline] + pub fn align(&mut self) -> _ALIGNW { + _ALIGNW { w: self } + } + #[doc = "Bit 10 - End of conversion selection"] + #[inline] + pub fn eocs(&mut self) -> _EOCSW { + _EOCSW { w: self } + } + #[doc = "Bit 9 - DMA disable selection (for single ADC mode)"] + #[inline] + pub fn dds(&mut self) -> _DDSW { + _DDSW { w: self } + } + #[doc = "Bit 8 - Direct memory access mode (for single ADC mode)"] + #[inline] + pub fn dma(&mut self) -> _DMAW { + _DMAW { w: self } + } + #[doc = "Bit 1 - Continuous conversion"] + #[inline] + pub fn cont(&mut self) -> _CONTW { + _CONTW { w: self } + } + #[doc = "Bit 0 - A/D Converter ON / OFF"] + #[inline] + pub fn adon(&mut self) -> _ADONW { + _ADONW { w: self } + } +} diff --git a/src/adc1/csr/mod.rs b/src/adc1/csr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a05a0133f94531003550dea721c7ef7dcd883ff5 --- /dev/null +++ b/src/adc1/csr/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWD1R { + bits: bool, +} +impl AWD1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOC1R { + bits: bool, +} +impl EOC1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOC1R { + bits: bool, +} +impl JEOC1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSTRT1R { + bits: bool, +} +impl JSTRT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STRT1R { + bits: bool, +} +impl STRT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVR1R { + bits: bool, +} +impl OVR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWD1W<'a> { + w: &'a mut W, +} +impl<'a> _AWD1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOC1W<'a> { + w: &'a mut W, +} +impl<'a> _EOC1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOC1W<'a> { + w: &'a mut W, +} +impl<'a> _JEOC1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSTRT1W<'a> { + w: &'a mut W, +} +impl<'a> _JSTRT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STRT1W<'a> { + w: &'a mut W, +} +impl<'a> _STRT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVR1W<'a> { + w: &'a mut W, +} +impl<'a> _OVR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Analog watchdog flag of ADC1"] + #[inline] + pub fn awd1(&self) -> AWD1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWD1R { bits } + } + #[doc = "Bit 1 - End of conversion of ADC1"] + #[inline] + pub fn eoc1(&self) -> EOC1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOC1R { bits } + } + #[doc = "Bit 2 - Injected channel end of conversion of ADC1"] + #[inline] + pub fn jeoc1(&self) -> JEOC1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOC1R { bits } + } + #[doc = "Bit 3 - Injected channel Start flag of ADC1"] + #[inline] + pub fn jstrt1(&self) -> JSTRT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSTRT1R { bits } + } + #[doc = "Bit 4 - Regular channel Start flag of ADC1"] + #[inline] + pub fn strt1(&self) -> STRT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STRT1R { bits } + } + #[doc = "Bit 5 - Overrun flag of ADC1"] + #[inline] + pub fn ovr1(&self) -> OVR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Analog watchdog flag of ADC1"] + #[inline] + pub fn awd1(&mut self) -> _AWD1W { + _AWD1W { w: self } + } + #[doc = "Bit 1 - End of conversion of ADC1"] + #[inline] + pub fn eoc1(&mut self) -> _EOC1W { + _EOC1W { w: self } + } + #[doc = "Bit 2 - Injected channel end of conversion of ADC1"] + #[inline] + pub fn jeoc1(&mut self) -> _JEOC1W { + _JEOC1W { w: self } + } + #[doc = "Bit 3 - Injected channel Start flag of ADC1"] + #[inline] + pub fn jstrt1(&mut self) -> _JSTRT1W { + _JSTRT1W { w: self } + } + #[doc = "Bit 4 - Regular channel Start flag of ADC1"] + #[inline] + pub fn strt1(&mut self) -> _STRT1W { + _STRT1W { w: self } + } + #[doc = "Bit 5 - Overrun flag of ADC1"] + #[inline] + pub fn ovr1(&mut self) -> _OVR1W { + _OVR1W { w: self } + } +} diff --git a/src/adc1/dr/mod.rs b/src/adc1/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2b8998e594a74540daf33b502ec31bd55e21e4e9 --- /dev/null +++ b/src/adc1/dr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATAR { + bits: u16, +} +impl DATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Regular data"] + #[inline] + pub fn data(&self) -> DATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DATAR { bits } + } +} diff --git a/src/adc1/htr/mod.rs b/src/adc1/htr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f135f71feb45f10c445d5b25df1d77d7ce78170e --- /dev/null +++ b/src/adc1/htr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::HTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct HTR { + bits: u16, +} +impl HTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _HTW<'a> { + w: &'a mut W, +} +impl<'a> _HTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Analog watchdog higher threshold"] + #[inline] + pub fn ht(&self) -> HTR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + HTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4095 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Analog watchdog higher threshold"] + #[inline] + pub fn ht(&mut self) -> _HTW { + _HTW { w: self } + } +} diff --git a/src/adc1/jdr1/mod.rs b/src/adc1/jdr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2203297b23a4fd69a458e4e256d8875173caae8c --- /dev/null +++ b/src/adc1/jdr1/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::JDR1 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u16, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Injected data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JDATAR { bits } + } +} diff --git a/src/adc1/jdr2/mod.rs b/src/adc1/jdr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..afd0b2f8709a49b39aece6d0b48784637d2c270d --- /dev/null +++ b/src/adc1/jdr2/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::JDR2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u16, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Injected data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JDATAR { bits } + } +} diff --git a/src/adc1/jdr3/mod.rs b/src/adc1/jdr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8a0efa03c6bb4bb5a564b59f9a267f3eeeb2d9aa --- /dev/null +++ b/src/adc1/jdr3/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::JDR3 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u16, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Injected data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JDATAR { bits } + } +} diff --git a/src/adc1/jdr4/mod.rs b/src/adc1/jdr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5183c405e89d056230bb4f74382e9ef76b6f5d14 --- /dev/null +++ b/src/adc1/jdr4/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::JDR4 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u16, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Injected data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JDATAR { bits } + } +} diff --git a/src/adc1/jofr1/mod.rs b/src/adc1/jofr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..35a168be9325a0b408366278ff1ae585abfa8fe1 --- /dev/null +++ b/src/adc1/jofr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::JOFR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JOFFSET1R { + bits: u16, +} +impl JOFFSET1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JOFFSET1W<'a> { + w: &'a mut W, +} +impl<'a> _JOFFSET1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset1(&self) -> JOFFSET1R { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JOFFSET1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset1(&mut self) -> _JOFFSET1W { + _JOFFSET1W { w: self } + } +} diff --git a/src/adc1/jofr2/mod.rs b/src/adc1/jofr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..901cb79495225570097afb181f78842c0ff956f7 --- /dev/null +++ b/src/adc1/jofr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::JOFR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JOFFSET2R { + bits: u16, +} +impl JOFFSET2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JOFFSET2W<'a> { + w: &'a mut W, +} +impl<'a> _JOFFSET2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset2(&self) -> JOFFSET2R { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JOFFSET2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset2(&mut self) -> _JOFFSET2W { + _JOFFSET2W { w: self } + } +} diff --git a/src/adc1/jofr3/mod.rs b/src/adc1/jofr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..91ae62dfd3c3648bbc579137b8f71cb56c9010d6 --- /dev/null +++ b/src/adc1/jofr3/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::JOFR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JOFFSET3R { + bits: u16, +} +impl JOFFSET3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JOFFSET3W<'a> { + w: &'a mut W, +} +impl<'a> _JOFFSET3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset3(&self) -> JOFFSET3R { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JOFFSET3R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset3(&mut self) -> _JOFFSET3W { + _JOFFSET3W { w: self } + } +} diff --git a/src/adc1/jofr4/mod.rs b/src/adc1/jofr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ea5ae85de56f19a8003fa23ca5c51e63bda168c6 --- /dev/null +++ b/src/adc1/jofr4/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::JOFR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JOFFSET4R { + bits: u16, +} +impl JOFFSET4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JOFFSET4W<'a> { + w: &'a mut W, +} +impl<'a> _JOFFSET4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset4(&self) -> JOFFSET4R { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + JOFFSET4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Data offset for injected channel x"] + #[inline] + pub fn joffset4(&mut self) -> _JOFFSET4W { + _JOFFSET4W { w: self } + } +} diff --git a/src/adc1/jsqr/mod.rs b/src/adc1/jsqr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b555c422dbf419b1c170532564fcac9980763ae9 --- /dev/null +++ b/src/adc1/jsqr/mod.rs @@ -0,0 +1,269 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::JSQR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JLR { + bits: u8, +} +impl JLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JSQ4R { + bits: u8, +} +impl JSQ4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JSQ3R { + bits: u8, +} +impl JSQ3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JSQ2R { + bits: u8, +} +impl JSQ2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JSQ1R { + bits: u8, +} +impl JSQ1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JLW<'a> { + w: &'a mut W, +} +impl<'a> _JLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSQ4W<'a> { + w: &'a mut W, +} +impl<'a> _JSQ4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSQ3W<'a> { + w: &'a mut W, +} +impl<'a> _JSQ3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSQ2W<'a> { + w: &'a mut W, +} +impl<'a> _JSQ2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSQ1W<'a> { + w: &'a mut W, +} +impl<'a> _JSQ1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:21 - Injected sequence length"] + #[inline] + pub fn jl(&self) -> JLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JLR { bits } + } + #[doc = "Bits 15:19 - 4th conversion in injected sequence"] + #[inline] + pub fn jsq4(&self) -> JSQ4R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JSQ4R { bits } + } + #[doc = "Bits 10:14 - 3rd conversion in injected sequence"] + #[inline] + pub fn jsq3(&self) -> JSQ3R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JSQ3R { bits } + } + #[doc = "Bits 5:9 - 2nd conversion in injected sequence"] + #[inline] + pub fn jsq2(&self) -> JSQ2R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JSQ2R { bits } + } + #[doc = "Bits 0:4 - 1st conversion in injected sequence"] + #[inline] + pub fn jsq1(&self) -> JSQ1R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JSQ1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:21 - Injected sequence length"] + #[inline] + pub fn jl(&mut self) -> _JLW { + _JLW { w: self } + } + #[doc = "Bits 15:19 - 4th conversion in injected sequence"] + #[inline] + pub fn jsq4(&mut self) -> _JSQ4W { + _JSQ4W { w: self } + } + #[doc = "Bits 10:14 - 3rd conversion in injected sequence"] + #[inline] + pub fn jsq3(&mut self) -> _JSQ3W { + _JSQ3W { w: self } + } + #[doc = "Bits 5:9 - 2nd conversion in injected sequence"] + #[inline] + pub fn jsq2(&mut self) -> _JSQ2W { + _JSQ2W { w: self } + } + #[doc = "Bits 0:4 - 1st conversion in injected sequence"] + #[inline] + pub fn jsq1(&mut self) -> _JSQ1W { + _JSQ1W { w: self } + } +} diff --git a/src/adc1/ltr/mod.rs b/src/adc1/ltr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f0da58517fc53d395661728ea7d3e36395aa4da3 --- /dev/null +++ b/src/adc1/ltr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LTR { + bits: u16, +} +impl LTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _LTW<'a> { + w: &'a mut W, +} +impl<'a> _LTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Analog watchdog lower threshold"] + #[inline] + pub fn lt(&self) -> LTR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + LTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Analog watchdog lower threshold"] + #[inline] + pub fn lt(&mut self) -> _LTW { + _LTW { w: self } + } +} diff --git a/src/adc1/mod.rs b/src/adc1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19dc57b414d2361395a574bcf59296ff4ad5b4a6 --- /dev/null +++ b/src/adc1/mod.rs @@ -0,0 +1,181 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - status register"] + pub sr: SR, + #[doc = "0x04 - control register 1"] + pub cr1: CR1, + #[doc = "0x08 - control register 2"] + pub cr2: CR2, + #[doc = "0x0c - sample time register 1"] + pub smpr1: SMPR1, + #[doc = "0x10 - sample time register 2"] + pub smpr2: SMPR2, + #[doc = "0x14 - injected channel data offset register x"] + pub jofr1: JOFR1, + #[doc = "0x18 - injected channel data offset register x"] + pub jofr2: JOFR2, + #[doc = "0x1c - injected channel data offset register x"] + pub jofr3: JOFR3, + #[doc = "0x20 - injected channel data offset register x"] + pub jofr4: JOFR4, + #[doc = "0x24 - watchdog higher threshold register"] + pub htr: HTR, + #[doc = "0x28 - watchdog lower threshold register"] + pub ltr: LTR, + #[doc = "0x2c - regular sequence register 1"] + pub sqr1: SQR1, + #[doc = "0x30 - regular sequence register 2"] + pub sqr2: SQR2, + #[doc = "0x34 - regular sequence register 3"] + pub sqr3: SQR3, + #[doc = "0x38 - injected sequence register"] + pub jsqr: JSQR, + #[doc = "0x3c - injected data register x"] + pub jdr1: JDR1, + #[doc = "0x40 - injected data register x"] + pub jdr2: JDR2, + #[doc = "0x44 - injected data register x"] + pub jdr3: JDR3, + #[doc = "0x48 - injected data register x"] + pub jdr4: JDR4, + #[doc = "0x4c - regular data register"] + pub dr: DR, + _reserved0: [u8; 688usize], + #[doc = "0x300 - Common status register"] + pub csr: CSR, + #[doc = "0x304 - common control register"] + pub ccr: CCR, +} +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "sample time register 1"] +pub struct SMPR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "sample time register 1"] +pub mod smpr1; +#[doc = "sample time register 2"] +pub struct SMPR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "sample time register 2"] +pub mod smpr2; +#[doc = "injected channel data offset register x"] +pub struct JOFR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel data offset register x"] +pub mod jofr1; +#[doc = "injected channel data offset register x"] +pub struct JOFR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel data offset register x"] +pub mod jofr2; +#[doc = "injected channel data offset register x"] +pub struct JOFR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel data offset register x"] +pub mod jofr3; +#[doc = "injected channel data offset register x"] +pub struct JOFR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel data offset register x"] +pub mod jofr4; +#[doc = "watchdog higher threshold register"] +pub struct HTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "watchdog higher threshold register"] +pub mod htr; +#[doc = "watchdog lower threshold register"] +pub struct LTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "watchdog lower threshold register"] +pub mod ltr; +#[doc = "regular sequence register 1"] +pub struct SQR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "regular sequence register 1"] +pub mod sqr1; +#[doc = "regular sequence register 2"] +pub struct SQR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "regular sequence register 2"] +pub mod sqr2; +#[doc = "regular sequence register 3"] +pub struct SQR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "regular sequence register 3"] +pub mod sqr3; +#[doc = "injected sequence register"] +pub struct JSQR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected sequence register"] +pub mod jsqr; +#[doc = "injected data register x"] +pub struct JDR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected data register x"] +pub mod jdr1; +#[doc = "injected data register x"] +pub struct JDR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected data register x"] +pub mod jdr2; +#[doc = "injected data register x"] +pub struct JDR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected data register x"] +pub mod jdr3; +#[doc = "injected data register x"] +pub struct JDR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected data register x"] +pub mod jdr4; +#[doc = "regular data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "regular data register"] +pub mod dr; +#[doc = "Common status register"] +pub struct CSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Common status register"] +pub mod csr; +#[doc = "common control register"] +pub struct CCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "common control register"] +pub mod ccr; diff --git a/src/adc1/smpr1/mod.rs b/src/adc1/smpr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..abb6e9e64f31a77e271a4d3ef21f7266471b73df --- /dev/null +++ b/src/adc1/smpr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMPR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SMPX_XR { + bits: u32, +} +impl SMPX_XR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SMPX_XW<'a> { + w: &'a mut W, +} +impl<'a> _SMPX_XW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Sample time bits"] + #[inline] + pub fn smpx_x(&self) -> SMPX_XR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + SMPX_XR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Sample time bits"] + #[inline] + pub fn smpx_x(&mut self) -> _SMPX_XW { + _SMPX_XW { w: self } + } +} diff --git a/src/adc1/smpr2/mod.rs b/src/adc1/smpr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c93fb8198f26839d65ccdaa2617e6243955ff044 --- /dev/null +++ b/src/adc1/smpr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMPR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SMPX_XR { + bits: u32, +} +impl SMPX_XR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SMPX_XW<'a> { + w: &'a mut W, +} +impl<'a> _SMPX_XW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Sample time bits"] + #[inline] + pub fn smpx_x(&self) -> SMPX_XR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + SMPX_XR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Sample time bits"] + #[inline] + pub fn smpx_x(&mut self) -> _SMPX_XW { + _SMPX_XW { w: self } + } +} diff --git a/src/adc1/sqr1/mod.rs b/src/adc1/sqr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..40b25ac7ca3f5986ff705873db56b09653709733 --- /dev/null +++ b/src/adc1/sqr1/mod.rs @@ -0,0 +1,269 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SQR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LR { + bits: u8, +} +impl LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ16R { + bits: u8, +} +impl SQ16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ15R { + bits: u8, +} +impl SQ15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ14R { + bits: u8, +} +impl SQ14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ13R { + bits: u8, +} +impl SQ13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _LW<'a> { + w: &'a mut W, +} +impl<'a> _LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ16W<'a> { + w: &'a mut W, +} +impl<'a> _SQ16W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ15W<'a> { + w: &'a mut W, +} +impl<'a> _SQ15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ14W<'a> { + w: &'a mut W, +} +impl<'a> _SQ14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ13W<'a> { + w: &'a mut W, +} +impl<'a> _SQ13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:23 - Regular channel sequence length"] + #[inline] + pub fn l(&self) -> LR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + LR { bits } + } + #[doc = "Bits 15:19 - 16th conversion in regular sequence"] + #[inline] + pub fn sq16(&self) -> SQ16R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ16R { bits } + } + #[doc = "Bits 10:14 - 15th conversion in regular sequence"] + #[inline] + pub fn sq15(&self) -> SQ15R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ15R { bits } + } + #[doc = "Bits 5:9 - 14th conversion in regular sequence"] + #[inline] + pub fn sq14(&self) -> SQ14R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ14R { bits } + } + #[doc = "Bits 0:4 - 13th conversion in regular sequence"] + #[inline] + pub fn sq13(&self) -> SQ13R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ13R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:23 - Regular channel sequence length"] + #[inline] + pub fn l(&mut self) -> _LW { + _LW { w: self } + } + #[doc = "Bits 15:19 - 16th conversion in regular sequence"] + #[inline] + pub fn sq16(&mut self) -> _SQ16W { + _SQ16W { w: self } + } + #[doc = "Bits 10:14 - 15th conversion in regular sequence"] + #[inline] + pub fn sq15(&mut self) -> _SQ15W { + _SQ15W { w: self } + } + #[doc = "Bits 5:9 - 14th conversion in regular sequence"] + #[inline] + pub fn sq14(&mut self) -> _SQ14W { + _SQ14W { w: self } + } + #[doc = "Bits 0:4 - 13th conversion in regular sequence"] + #[inline] + pub fn sq13(&mut self) -> _SQ13W { + _SQ13W { w: self } + } +} diff --git a/src/adc1/sqr2/mod.rs b/src/adc1/sqr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c42ce1e1b1e7086bb09abc2445bb06f85625719d --- /dev/null +++ b/src/adc1/sqr2/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SQR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SQ12R { + bits: u8, +} +impl SQ12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ11R { + bits: u8, +} +impl SQ11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ10R { + bits: u8, +} +impl SQ10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ9R { + bits: u8, +} +impl SQ9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ8R { + bits: u8, +} +impl SQ8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ7R { + bits: u8, +} +impl SQ7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SQ12W<'a> { + w: &'a mut W, +} +impl<'a> _SQ12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ11W<'a> { + w: &'a mut W, +} +impl<'a> _SQ11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ10W<'a> { + w: &'a mut W, +} +impl<'a> _SQ10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ9W<'a> { + w: &'a mut W, +} +impl<'a> _SQ9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ8W<'a> { + w: &'a mut W, +} +impl<'a> _SQ8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ7W<'a> { + w: &'a mut W, +} +impl<'a> _SQ7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:29 - 12th conversion in regular sequence"] + #[inline] + pub fn sq12(&self) -> SQ12R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ12R { bits } + } + #[doc = "Bits 20:24 - 11th conversion in regular sequence"] + #[inline] + pub fn sq11(&self) -> SQ11R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ11R { bits } + } + #[doc = "Bits 15:19 - 10th conversion in regular sequence"] + #[inline] + pub fn sq10(&self) -> SQ10R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ10R { bits } + } + #[doc = "Bits 10:14 - 9th conversion in regular sequence"] + #[inline] + pub fn sq9(&self) -> SQ9R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ9R { bits } + } + #[doc = "Bits 5:9 - 8th conversion in regular sequence"] + #[inline] + pub fn sq8(&self) -> SQ8R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ8R { bits } + } + #[doc = "Bits 0:4 - 7th conversion in regular sequence"] + #[inline] + pub fn sq7(&self) -> SQ7R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ7R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:29 - 12th conversion in regular sequence"] + #[inline] + pub fn sq12(&mut self) -> _SQ12W { + _SQ12W { w: self } + } + #[doc = "Bits 20:24 - 11th conversion in regular sequence"] + #[inline] + pub fn sq11(&mut self) -> _SQ11W { + _SQ11W { w: self } + } + #[doc = "Bits 15:19 - 10th conversion in regular sequence"] + #[inline] + pub fn sq10(&mut self) -> _SQ10W { + _SQ10W { w: self } + } + #[doc = "Bits 10:14 - 9th conversion in regular sequence"] + #[inline] + pub fn sq9(&mut self) -> _SQ9W { + _SQ9W { w: self } + } + #[doc = "Bits 5:9 - 8th conversion in regular sequence"] + #[inline] + pub fn sq8(&mut self) -> _SQ8W { + _SQ8W { w: self } + } + #[doc = "Bits 0:4 - 7th conversion in regular sequence"] + #[inline] + pub fn sq7(&mut self) -> _SQ7W { + _SQ7W { w: self } + } +} diff --git a/src/adc1/sqr3/mod.rs b/src/adc1/sqr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c94f136665275ef898bbe18dd7b927946f5dfcc8 --- /dev/null +++ b/src/adc1/sqr3/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SQR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SQ6R { + bits: u8, +} +impl SQ6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ5R { + bits: u8, +} +impl SQ5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ4R { + bits: u8, +} +impl SQ4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ3R { + bits: u8, +} +impl SQ3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ2R { + bits: u8, +} +impl SQ2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SQ1R { + bits: u8, +} +impl SQ1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SQ6W<'a> { + w: &'a mut W, +} +impl<'a> _SQ6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ5W<'a> { + w: &'a mut W, +} +impl<'a> _SQ5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ4W<'a> { + w: &'a mut W, +} +impl<'a> _SQ4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ3W<'a> { + w: &'a mut W, +} +impl<'a> _SQ3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ2W<'a> { + w: &'a mut W, +} +impl<'a> _SQ2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SQ1W<'a> { + w: &'a mut W, +} +impl<'a> _SQ1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:29 - 6th conversion in regular sequence"] + #[inline] + pub fn sq6(&self) -> SQ6R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ6R { bits } + } + #[doc = "Bits 20:24 - 5th conversion in regular sequence"] + #[inline] + pub fn sq5(&self) -> SQ5R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ5R { bits } + } + #[doc = "Bits 15:19 - 4th conversion in regular sequence"] + #[inline] + pub fn sq4(&self) -> SQ4R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ4R { bits } + } + #[doc = "Bits 10:14 - 3rd conversion in regular sequence"] + #[inline] + pub fn sq3(&self) -> SQ3R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ3R { bits } + } + #[doc = "Bits 5:9 - 2nd conversion in regular sequence"] + #[inline] + pub fn sq2(&self) -> SQ2R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ2R { bits } + } + #[doc = "Bits 0:4 - 1st conversion in regular sequence"] + #[inline] + pub fn sq1(&self) -> SQ1R { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SQ1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:29 - 6th conversion in regular sequence"] + #[inline] + pub fn sq6(&mut self) -> _SQ6W { + _SQ6W { w: self } + } + #[doc = "Bits 20:24 - 5th conversion in regular sequence"] + #[inline] + pub fn sq5(&mut self) -> _SQ5W { + _SQ5W { w: self } + } + #[doc = "Bits 15:19 - 4th conversion in regular sequence"] + #[inline] + pub fn sq4(&mut self) -> _SQ4W { + _SQ4W { w: self } + } + #[doc = "Bits 10:14 - 3rd conversion in regular sequence"] + #[inline] + pub fn sq3(&mut self) -> _SQ3W { + _SQ3W { w: self } + } + #[doc = "Bits 5:9 - 2nd conversion in regular sequence"] + #[inline] + pub fn sq2(&mut self) -> _SQ2W { + _SQ2W { w: self } + } + #[doc = "Bits 0:4 - 1st conversion in regular sequence"] + #[inline] + pub fn sq1(&mut self) -> _SQ1W { + _SQ1W { w: self } + } +} diff --git a/src/adc1/sr/mod.rs b/src/adc1/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b83516b30f1818c0d9ff1c4c74e92b167a960e1a --- /dev/null +++ b/src/adc1/sr/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OVRR { + bits: bool, +} +impl OVRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STRTR { + bits: bool, +} +impl STRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSTRTR { + bits: bool, +} +impl JSTRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCR { + bits: bool, +} +impl JEOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOCR { + bits: bool, +} +impl EOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDR { + bits: bool, +} +impl AWDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OVRW<'a> { + w: &'a mut W, +} +impl<'a> _OVRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STRTW<'a> { + w: &'a mut W, +} +impl<'a> _STRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSTRTW<'a> { + w: &'a mut W, +} +impl<'a> _JSTRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOCW<'a> { + w: &'a mut W, +} +impl<'a> _EOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDW<'a> { + w: &'a mut W, +} +impl<'a> _AWDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 5 - Overrun"] + #[inline] + pub fn ovr(&self) -> OVRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRR { bits } + } + #[doc = "Bit 4 - Regular channel start flag"] + #[inline] + pub fn strt(&self) -> STRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STRTR { bits } + } + #[doc = "Bit 3 - Injected channel start flag"] + #[inline] + pub fn jstrt(&self) -> JSTRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSTRTR { bits } + } + #[doc = "Bit 2 - Injected channel end of conversion"] + #[inline] + pub fn jeoc(&self) -> JEOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCR { bits } + } + #[doc = "Bit 1 - Regular channel end of conversion"] + #[inline] + pub fn eoc(&self) -> EOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOCR { bits } + } + #[doc = "Bit 0 - Analog watchdog flag"] + #[inline] + pub fn awd(&self) -> AWDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - Overrun"] + #[inline] + pub fn ovr(&mut self) -> _OVRW { + _OVRW { w: self } + } + #[doc = "Bit 4 - Regular channel start flag"] + #[inline] + pub fn strt(&mut self) -> _STRTW { + _STRTW { w: self } + } + #[doc = "Bit 3 - Injected channel start flag"] + #[inline] + pub fn jstrt(&mut self) -> _JSTRTW { + _JSTRTW { w: self } + } + #[doc = "Bit 2 - Injected channel end of conversion"] + #[inline] + pub fn jeoc(&mut self) -> _JEOCW { + _JEOCW { w: self } + } + #[doc = "Bit 1 - Regular channel end of conversion"] + #[inline] + pub fn eoc(&mut self) -> _EOCW { + _EOCW { w: self } + } + #[doc = "Bit 0 - Analog watchdog flag"] + #[inline] + pub fn awd(&mut self) -> _AWDW { + _AWDW { w: self } + } +} diff --git a/src/aes/cr/mod.rs b/src/aes/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..099594c2641bacaac371b122fa951795edb18353 --- /dev/null +++ b/src/aes/cr/mod.rs @@ -0,0 +1,600 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMAOUTENR { + bits: bool, +} +impl DMAOUTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAINENR { + bits: bool, +} +impl DMAINENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIER { + bits: bool, +} +impl ERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCFIER { + bits: bool, +} +impl CCFIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRCR { + bits: bool, +} +impl ERRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCFCR { + bits: bool, +} +impl CCFCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHMODR { + bits: u8, +} +impl CHMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER { + bits: u8, +} +impl MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATATYPER { + bits: u8, +} +impl DATATYPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DMAOUTENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAOUTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAINENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAINENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCFIEW<'a> { + w: &'a mut W, +} +impl<'a> _CCFIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRCW<'a> { + w: &'a mut W, +} +impl<'a> _ERRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCFCW<'a> { + w: &'a mut W, +} +impl<'a> _CCFCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHMODW<'a> { + w: &'a mut W, +} +impl<'a> _CHMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODEW<'a> { + w: &'a mut W, +} +impl<'a> _MODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATATYPEW<'a> { + w: &'a mut W, +} +impl<'a> _DATATYPEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - Enable DMA management of data output phase"] + #[inline] + pub fn dmaouten(&self) -> DMAOUTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAOUTENR { bits } + } + #[doc = "Bit 11 - Enable DMA management of data input phase"] + #[inline] + pub fn dmainen(&self) -> DMAINENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAINENR { bits } + } + #[doc = "Bit 10 - Error interrupt enable"] + #[inline] + pub fn errie(&self) -> ERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIER { bits } + } + #[doc = "Bit 9 - CCF flag interrupt enable"] + #[inline] + pub fn ccfie(&self) -> CCFIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCFIER { bits } + } + #[doc = "Bit 8 - Error clear"] + #[inline] + pub fn errc(&self) -> ERRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRCR { bits } + } + #[doc = "Bit 7 - Computation Complete Flag Clear"] + #[inline] + pub fn ccfc(&self) -> CCFCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCFCR { bits } + } + #[doc = "Bits 5:6 - AES chaining mode"] + #[inline] + pub fn chmod(&self) -> CHMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHMODR { bits } + } + #[doc = "Bits 3:4 - AES operating mode"] + #[inline] + pub fn mode(&self) -> MODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER { bits } + } + #[doc = "Bits 1:2 - Data type selection (for data in and data out to/from the cryptographic block)"] + #[inline] + pub fn datatype(&self) -> DATATYPER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATATYPER { bits } + } + #[doc = "Bit 0 - AES enable"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - Enable DMA management of data output phase"] + #[inline] + pub fn dmaouten(&mut self) -> _DMAOUTENW { + _DMAOUTENW { w: self } + } + #[doc = "Bit 11 - Enable DMA management of data input phase"] + #[inline] + pub fn dmainen(&mut self) -> _DMAINENW { + _DMAINENW { w: self } + } + #[doc = "Bit 10 - Error interrupt enable"] + #[inline] + pub fn errie(&mut self) -> _ERRIEW { + _ERRIEW { w: self } + } + #[doc = "Bit 9 - CCF flag interrupt enable"] + #[inline] + pub fn ccfie(&mut self) -> _CCFIEW { + _CCFIEW { w: self } + } + #[doc = "Bit 8 - Error clear"] + #[inline] + pub fn errc(&mut self) -> _ERRCW { + _ERRCW { w: self } + } + #[doc = "Bit 7 - Computation Complete Flag Clear"] + #[inline] + pub fn ccfc(&mut self) -> _CCFCW { + _CCFCW { w: self } + } + #[doc = "Bits 5:6 - AES chaining mode"] + #[inline] + pub fn chmod(&mut self) -> _CHMODW { + _CHMODW { w: self } + } + #[doc = "Bits 3:4 - AES operating mode"] + #[inline] + pub fn mode(&mut self) -> _MODEW { + _MODEW { w: self } + } + #[doc = "Bits 1:2 - Data type selection (for data in and data out to/from the cryptographic block)"] + #[inline] + pub fn datatype(&mut self) -> _DATATYPEW { + _DATATYPEW { w: self } + } + #[doc = "Bit 0 - AES enable"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/aes/dinr/mod.rs b/src/aes/dinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab433cb24f56df5b066f661e3db09540ffb06f15 --- /dev/null +++ b/src/aes/dinr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_DINRR { + bits: u32, +} +impl AES_DINRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_DINRW<'a> { + w: &'a mut W, +} +impl<'a> _AES_DINRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data Input Register"] + #[inline] + pub fn aes_dinr(&self) -> AES_DINRR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_DINRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data Input Register"] + #[inline] + pub fn aes_dinr(&mut self) -> _AES_DINRW { + _AES_DINRW { w: self } + } +} diff --git a/src/aes/doutr/mod.rs b/src/aes/doutr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..32cc102422b0c2b4f573202a1fcf3c8fd613fdca --- /dev/null +++ b/src/aes/doutr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DOUTR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct AES_DOUTRR { + bits: u32, +} +impl AES_DOUTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data output register"] + #[inline] + pub fn aes_doutr(&self) -> AES_DOUTRR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_DOUTRR { bits } + } +} diff --git a/src/aes/ivr0/mod.rs b/src/aes/ivr0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dd7b1ed07c4d9bbd4932d194b80906fc2930bbb0 --- /dev/null +++ b/src/aes/ivr0/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IVR0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_IVR0R { + bits: u32, +} +impl AES_IVR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_IVR0W<'a> { + w: &'a mut W, +} +impl<'a> _AES_IVR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - initialization vector register (LSB IVR [31:0])"] + #[inline] + pub fn aes_ivr0(&self) -> AES_IVR0R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_IVR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - initialization vector register (LSB IVR [31:0])"] + #[inline] + pub fn aes_ivr0(&mut self) -> _AES_IVR0W { + _AES_IVR0W { w: self } + } +} diff --git a/src/aes/ivr1/mod.rs b/src/aes/ivr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a275292138533c376f6a6e98620e64051e708007 --- /dev/null +++ b/src/aes/ivr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IVR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_IVR1R { + bits: u32, +} +impl AES_IVR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_IVR1W<'a> { + w: &'a mut W, +} +impl<'a> _AES_IVR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Initialization Vector Register (IVR [63:32])"] + #[inline] + pub fn aes_ivr1(&self) -> AES_IVR1R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_IVR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Initialization Vector Register (IVR [63:32])"] + #[inline] + pub fn aes_ivr1(&mut self) -> _AES_IVR1W { + _AES_IVR1W { w: self } + } +} diff --git a/src/aes/ivr2/mod.rs b/src/aes/ivr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..68d5b97968f2958fdfd9369d6a380fdf91e7a771 --- /dev/null +++ b/src/aes/ivr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IVR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_IVR2R { + bits: u32, +} +impl AES_IVR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_IVR2W<'a> { + w: &'a mut W, +} +impl<'a> _AES_IVR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Initialization Vector Register (IVR [95:64])"] + #[inline] + pub fn aes_ivr2(&self) -> AES_IVR2R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_IVR2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Initialization Vector Register (IVR [95:64])"] + #[inline] + pub fn aes_ivr2(&mut self) -> _AES_IVR2W { + _AES_IVR2W { w: self } + } +} diff --git a/src/aes/ivr3/mod.rs b/src/aes/ivr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aad7ccc7bebdb4cead7e0535fbeb465e0600a2ed --- /dev/null +++ b/src/aes/ivr3/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IVR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_IVR3R { + bits: u32, +} +impl AES_IVR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_IVR3W<'a> { + w: &'a mut W, +} +impl<'a> _AES_IVR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Initialization Vector Register (MSB IVR [127:96])"] + #[inline] + pub fn aes_ivr3(&self) -> AES_IVR3R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_IVR3R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Initialization Vector Register (MSB IVR [127:96])"] + #[inline] + pub fn aes_ivr3(&mut self) -> _AES_IVR3W { + _AES_IVR3W { w: self } + } +} diff --git a/src/aes/keyr0/mod.rs b/src/aes/keyr0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f2dfcf751130c8c3012168d69ad48d87e754c05d --- /dev/null +++ b/src/aes/keyr0/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KEYR0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_KEYR0R { + bits: u32, +} +impl AES_KEYR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_KEYR0W<'a> { + w: &'a mut W, +} +impl<'a> _AES_KEYR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data Output Register (LSB key [31:0])"] + #[inline] + pub fn aes_keyr0(&self) -> AES_KEYR0R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_KEYR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data Output Register (LSB key [31:0])"] + #[inline] + pub fn aes_keyr0(&mut self) -> _AES_KEYR0W { + _AES_KEYR0W { w: self } + } +} diff --git a/src/aes/keyr1/mod.rs b/src/aes/keyr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a6ecc73c60f13ec4c84d48a04e6444ed9e4f5f23 --- /dev/null +++ b/src/aes/keyr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KEYR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_KEYR1R { + bits: u32, +} +impl AES_KEYR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_KEYR1W<'a> { + w: &'a mut W, +} +impl<'a> _AES_KEYR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - AES key register (key [63:32])"] + #[inline] + pub fn aes_keyr1(&self) -> AES_KEYR1R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_KEYR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - AES key register (key [63:32])"] + #[inline] + pub fn aes_keyr1(&mut self) -> _AES_KEYR1W { + _AES_KEYR1W { w: self } + } +} diff --git a/src/aes/keyr2/mod.rs b/src/aes/keyr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a819e4032f985ac6bc88d7cc65d1dbfd0a92dab4 --- /dev/null +++ b/src/aes/keyr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KEYR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_KEYR2R { + bits: u32, +} +impl AES_KEYR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_KEYR2W<'a> { + w: &'a mut W, +} +impl<'a> _AES_KEYR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - AES key register (key [95:64])"] + #[inline] + pub fn aes_keyr2(&self) -> AES_KEYR2R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_KEYR2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - AES key register (key [95:64])"] + #[inline] + pub fn aes_keyr2(&mut self) -> _AES_KEYR2W { + _AES_KEYR2W { w: self } + } +} diff --git a/src/aes/keyr3/mod.rs b/src/aes/keyr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..766305093f57834c19b776582ad90eb3c8713693 --- /dev/null +++ b/src/aes/keyr3/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KEYR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AES_KEYR3R { + bits: u32, +} +impl AES_KEYR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AES_KEYR3W<'a> { + w: &'a mut W, +} +impl<'a> _AES_KEYR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - AES key register (MSB key [127:96])"] + #[inline] + pub fn aes_keyr3(&self) -> AES_KEYR3R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AES_KEYR3R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - AES key register (MSB key [127:96])"] + #[inline] + pub fn aes_keyr3(&mut self) -> _AES_KEYR3W { + _AES_KEYR3W { w: self } + } +} diff --git a/src/aes/mod.rs b/src/aes/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c8fa60a5a5b83851554ce606505fad486cb4d7b6 --- /dev/null +++ b/src/aes/mod.rs @@ -0,0 +1,100 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register"] + pub cr: CR, + #[doc = "0x04 - status register"] + pub sr: SR, + #[doc = "0x08 - data input register"] + pub dinr: DINR, + #[doc = "0x0c - data output register"] + pub doutr: DOUTR, + #[doc = "0x10 - key register 0"] + pub keyr0: KEYR0, + #[doc = "0x14 - key register 1"] + pub keyr1: KEYR1, + #[doc = "0x18 - key register 2"] + pub keyr2: KEYR2, + #[doc = "0x1c - key register 3"] + pub keyr3: KEYR3, + #[doc = "0x20 - initialization vector register 0"] + pub ivr0: IVR0, + #[doc = "0x24 - initialization vector register 1"] + pub ivr1: IVR1, + #[doc = "0x28 - initialization vector register 2"] + pub ivr2: IVR2, + #[doc = "0x2c - initialization vector register 3"] + pub ivr3: IVR3, +} +#[doc = "control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register"] +pub mod cr; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "data input register"] +pub struct DINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data input register"] +pub mod dinr; +#[doc = "data output register"] +pub struct DOUTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data output register"] +pub mod doutr; +#[doc = "key register 0"] +pub struct KEYR0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "key register 0"] +pub mod keyr0; +#[doc = "key register 1"] +pub struct KEYR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "key register 1"] +pub mod keyr1; +#[doc = "key register 2"] +pub struct KEYR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "key register 2"] +pub mod keyr2; +#[doc = "key register 3"] +pub struct KEYR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "key register 3"] +pub mod keyr3; +#[doc = "initialization vector register 0"] +pub struct IVR0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "initialization vector register 0"] +pub mod ivr0; +#[doc = "initialization vector register 1"] +pub struct IVR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "initialization vector register 1"] +pub mod ivr1; +#[doc = "initialization vector register 2"] +pub struct IVR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "initialization vector register 2"] +pub mod ivr2; +#[doc = "initialization vector register 3"] +pub struct IVR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "initialization vector register 3"] +pub mod ivr3; diff --git a/src/aes/sr/mod.rs b/src/aes/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0b108dee3ab6d03ede7f186a0b83b94ba7794f11 --- /dev/null +++ b/src/aes/sr/mod.rs @@ -0,0 +1,113 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::SR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct WRERRR { + bits: bool, +} +impl WRERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDERRR { + bits: bool, +} +impl RDERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCFR { + bits: bool, +} +impl CCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 2 - Write error flag"] + #[inline] + pub fn wrerr(&self) -> WRERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRERRR { bits } + } + #[doc = "Bit 1 - Read error flag"] + #[inline] + pub fn rderr(&self) -> RDERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RDERRR { bits } + } + #[doc = "Bit 0 - Computation complete flag"] + #[inline] + pub fn ccf(&self) -> CCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCFR { bits } + } +} diff --git a/src/can1/btr/mod.rs b/src/can1/btr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6e97c92334c07751b745d88cd590661d96c2f5d4 --- /dev/null +++ b/src/can1/btr/mod.rs @@ -0,0 +1,346 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SILMR { + bits: bool, +} +impl SILMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LBKMR { + bits: bool, +} +impl LBKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SJWR { + bits: u8, +} +impl SJWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TS2R { + bits: u8, +} +impl TS2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TS1R { + bits: u8, +} +impl TS1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BRPR { + bits: u16, +} +impl BRPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SILMW<'a> { + w: &'a mut W, +} +impl<'a> _SILMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LBKMW<'a> { + w: &'a mut W, +} +impl<'a> _LBKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SJWW<'a> { + w: &'a mut W, +} +impl<'a> _SJWW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TS2W<'a> { + w: &'a mut W, +} +impl<'a> _TS2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TS1W<'a> { + w: &'a mut W, +} +impl<'a> _TS1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BRPW<'a> { + w: &'a mut W, +} +impl<'a> _BRPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - SILM"] + #[inline] + pub fn silm(&self) -> SILMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SILMR { bits } + } + #[doc = "Bit 30 - LBKM"] + #[inline] + pub fn lbkm(&self) -> LBKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LBKMR { bits } + } + #[doc = "Bits 24:25 - SJW"] + #[inline] + pub fn sjw(&self) -> SJWR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SJWR { bits } + } + #[doc = "Bits 20:22 - TS2"] + #[inline] + pub fn ts2(&self) -> TS2R { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TS2R { bits } + } + #[doc = "Bits 16:19 - TS1"] + #[inline] + pub fn ts1(&self) -> TS1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TS1R { bits } + } + #[doc = "Bits 0:9 - BRP"] + #[inline] + pub fn brp(&self) -> BRPR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + BRPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - SILM"] + #[inline] + pub fn silm(&mut self) -> _SILMW { + _SILMW { w: self } + } + #[doc = "Bit 30 - LBKM"] + #[inline] + pub fn lbkm(&mut self) -> _LBKMW { + _LBKMW { w: self } + } + #[doc = "Bits 24:25 - SJW"] + #[inline] + pub fn sjw(&mut self) -> _SJWW { + _SJWW { w: self } + } + #[doc = "Bits 20:22 - TS2"] + #[inline] + pub fn ts2(&mut self) -> _TS2W { + _TS2W { w: self } + } + #[doc = "Bits 16:19 - TS1"] + #[inline] + pub fn ts1(&mut self) -> _TS1W { + _TS1W { w: self } + } + #[doc = "Bits 0:9 - BRP"] + #[inline] + pub fn brp(&mut self) -> _BRPW { + _BRPW { w: self } + } +} diff --git a/src/can1/esr/mod.rs b/src/can1/esr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1b924c7089b0d8e89b4d6b601a8fb672c47782b9 --- /dev/null +++ b/src/can1/esr/mod.rs @@ -0,0 +1,240 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ESR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RECR { + bits: u8, +} +impl RECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TECR { + bits: u8, +} +impl TECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct LECR { + bits: u8, +} +impl LECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BOFFR { + bits: bool, +} +impl BOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPVFR { + bits: bool, +} +impl EPVFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EWGFR { + bits: bool, +} +impl EWGFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LECW<'a> { + w: &'a mut W, +} +impl<'a> _LECW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - REC"] + #[inline] + pub fn rec(&self) -> RECR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RECR { bits } + } + #[doc = "Bits 16:23 - TEC"] + #[inline] + pub fn tec(&self) -> TECR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TECR { bits } + } + #[doc = "Bits 4:6 - LEC"] + #[inline] + pub fn lec(&self) -> LECR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + LECR { bits } + } + #[doc = "Bit 2 - BOFF"] + #[inline] + pub fn boff(&self) -> BOFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BOFFR { bits } + } + #[doc = "Bit 1 - EPVF"] + #[inline] + pub fn epvf(&self) -> EPVFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPVFR { bits } + } + #[doc = "Bit 0 - EWGF"] + #[inline] + pub fn ewgf(&self) -> EWGFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EWGFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:6 - LEC"] + #[inline] + pub fn lec(&mut self) -> _LECW { + _LECW { w: self } + } +} diff --git a/src/can1/f0r1/mod.rs b/src/can1/f0r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..285ccbd57dd9aa5d7f1c035e2191c52e083a2a2a --- /dev/null +++ b/src/can1/f0r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F0R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f0r2/mod.rs b/src/can1/f0r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f2c9afd1b892199597a5fbf92e47be7a3b869ddd --- /dev/null +++ b/src/can1/f0r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F0R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f10r1/mod.rs b/src/can1/f10r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e13b1db8c4aa9fafda24698e83012bc9f586e48 --- /dev/null +++ b/src/can1/f10r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F10R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f10r2/mod.rs b/src/can1/f10r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6b6856b34a6946ea02dc1b12b11ea9b8fcf6ea3d --- /dev/null +++ b/src/can1/f10r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F10R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f11r1/mod.rs b/src/can1/f11r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bdae35d401947cce5692d0b1f553e74619abd6d6 --- /dev/null +++ b/src/can1/f11r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F11R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f11r2/mod.rs b/src/can1/f11r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5a1029cb5e95b4b3e7004dd1bd21a99b5815f63d --- /dev/null +++ b/src/can1/f11r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F11R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f12r1/mod.rs b/src/can1/f12r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5c52e9667cf529ae2b13fea7cfe6ce18192378d5 --- /dev/null +++ b/src/can1/f12r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F12R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f12r2/mod.rs b/src/can1/f12r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..793be08344d421477d9b54bd1d4c3e19cbf9d571 --- /dev/null +++ b/src/can1/f12r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F12R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f13r1/mod.rs b/src/can1/f13r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..08eb448ffccf6d53073a5e763657642d154002df --- /dev/null +++ b/src/can1/f13r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F13R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f13r2/mod.rs b/src/can1/f13r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fd660192b3c625aea314dc641b47f808ac414cfd --- /dev/null +++ b/src/can1/f13r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F13R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f14r1/mod.rs b/src/can1/f14r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..34a5c8b5a6f0f0e988a0d12fbe6a982a22d9018f --- /dev/null +++ b/src/can1/f14r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F14R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f14r2/mod.rs b/src/can1/f14r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b2152a39084f3cbdeb6b965b4480ff754018dd79 --- /dev/null +++ b/src/can1/f14r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F14R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f15r1/mod.rs b/src/can1/f15r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b5f41ee7cb6adcedf61f111be9647efa519729c7 --- /dev/null +++ b/src/can1/f15r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F15R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f15r2/mod.rs b/src/can1/f15r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2885cf705f02c37d18b4ff4ab4592f74fa2aae38 --- /dev/null +++ b/src/can1/f15r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F15R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f16r1/mod.rs b/src/can1/f16r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6489ca29d6e919efc4c60e52d0acc517abdd1fb9 --- /dev/null +++ b/src/can1/f16r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F16R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f16r2/mod.rs b/src/can1/f16r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cc9f96d1f0cf7ded8fac2f8a227259b2f9ba87c7 --- /dev/null +++ b/src/can1/f16r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F16R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f17r1/mod.rs b/src/can1/f17r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8f366b25b70601a81ce89a8f9f7603bf7a30839 --- /dev/null +++ b/src/can1/f17r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F17R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f17r2/mod.rs b/src/can1/f17r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..09bd58f3f8d73d30c1adb2d02f4bcd5c9e7398c9 --- /dev/null +++ b/src/can1/f17r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F17R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f18r1/mod.rs b/src/can1/f18r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bcee8142cdb9b69f5c4aba063db4ebebbf62e86e --- /dev/null +++ b/src/can1/f18r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F18R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f18r2/mod.rs b/src/can1/f18r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c5bff404dcc0e87f97c3bc2ba937880ce88950e0 --- /dev/null +++ b/src/can1/f18r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F18R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f19r1/mod.rs b/src/can1/f19r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..38c5fa7c581da16ed13e263409b11476d4e885c5 --- /dev/null +++ b/src/can1/f19r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F19R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f19r2/mod.rs b/src/can1/f19r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..09e4bd884ecfb892c0055c510eca866b38cce7e1 --- /dev/null +++ b/src/can1/f19r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F19R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f1r1/mod.rs b/src/can1/f1r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8f5f1aa8d77029d0305666877e0330e2851ad72d --- /dev/null +++ b/src/can1/f1r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F1R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f1r2/mod.rs b/src/can1/f1r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6dde7b8c45ec28d279753655848f747250f57241 --- /dev/null +++ b/src/can1/f1r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F1R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f20r1/mod.rs b/src/can1/f20r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f5879129b7e37a6e4852a0b13af0bb2db94f4f72 --- /dev/null +++ b/src/can1/f20r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F20R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f20r2/mod.rs b/src/can1/f20r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b1a4fc25d267be94fcc9c0cbc5d0d58b97571004 --- /dev/null +++ b/src/can1/f20r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F20R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f21r1/mod.rs b/src/can1/f21r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..67a5642c9f05f54ae94d2ef2cdf959ac27426558 --- /dev/null +++ b/src/can1/f21r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F21R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f21r2/mod.rs b/src/can1/f21r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..94a373421b5f38ea7ad2d28ecf5f38bfa8d3bae4 --- /dev/null +++ b/src/can1/f21r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F21R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f22r1/mod.rs b/src/can1/f22r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..471fbaba6acb1f695e3697ffb83d1e4d5bea6ea1 --- /dev/null +++ b/src/can1/f22r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F22R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f22r2/mod.rs b/src/can1/f22r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..75d71da9ec0e291895fe337682b817a7bee91669 --- /dev/null +++ b/src/can1/f22r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F22R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f23r1/mod.rs b/src/can1/f23r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c98ff8c510252e2e2c220b936e8552c242d006a4 --- /dev/null +++ b/src/can1/f23r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F23R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f23r2/mod.rs b/src/can1/f23r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..74638142557787d4022b5eb6ce8b1a8bba99e907 --- /dev/null +++ b/src/can1/f23r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F23R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f24r1/mod.rs b/src/can1/f24r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da345924c13df480284443a608985e935b47f171 --- /dev/null +++ b/src/can1/f24r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F24R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f24r2/mod.rs b/src/can1/f24r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab5e56b56d3d8d2a20b299a4e64a1b0ddf20b5ad --- /dev/null +++ b/src/can1/f24r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F24R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f25r1/mod.rs b/src/can1/f25r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d2760ae85b134594c92f70e947438162842a7d0e --- /dev/null +++ b/src/can1/f25r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F25R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f25r2/mod.rs b/src/can1/f25r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5cba54b3fa9d907a9c212a32e7c104229ed3aee4 --- /dev/null +++ b/src/can1/f25r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F25R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f26r1/mod.rs b/src/can1/f26r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d64b01178f4b64582110a793fd68871531919a32 --- /dev/null +++ b/src/can1/f26r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F26R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f26r2/mod.rs b/src/can1/f26r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8ceed4114e0195db4c22b97a02927db7a558fcf --- /dev/null +++ b/src/can1/f26r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F26R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f27r1/mod.rs b/src/can1/f27r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3c92ac77e1fba3b3af663295dd31b33439e4fb9a --- /dev/null +++ b/src/can1/f27r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F27R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f27r2/mod.rs b/src/can1/f27r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8f66469cb9dcff9573d6b4dc86f6ab306a2e9788 --- /dev/null +++ b/src/can1/f27r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F27R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f2r1/mod.rs b/src/can1/f2r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5fba510ff5fc263b39e783779cbe00986fac45ec --- /dev/null +++ b/src/can1/f2r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F2R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f2r2/mod.rs b/src/can1/f2r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f2798811d60eb2f701be68f6e736d842ce260fe4 --- /dev/null +++ b/src/can1/f2r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F2R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f3r1/mod.rs b/src/can1/f3r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f3411351fafa87a497e5a51f0763291f5c00f8d0 --- /dev/null +++ b/src/can1/f3r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F3R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f3r2/mod.rs b/src/can1/f3r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b5a0fa3631bfa17e7269c4c74bdd61ae533b590 --- /dev/null +++ b/src/can1/f3r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F3R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f4r1/mod.rs b/src/can1/f4r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b68e2de08264e14e6577d5e5972ab021e672500d --- /dev/null +++ b/src/can1/f4r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F4R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f4r2/mod.rs b/src/can1/f4r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8522be9a839507387f1ff4423eb84b972dcddde0 --- /dev/null +++ b/src/can1/f4r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F4R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f5r1/mod.rs b/src/can1/f5r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e3fedde4737f4c439e49aef4e635069220545926 --- /dev/null +++ b/src/can1/f5r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F5R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f5r2/mod.rs b/src/can1/f5r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0a7a65ca1106dfb09703f8f22b7830d0501da581 --- /dev/null +++ b/src/can1/f5r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F5R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f6r1/mod.rs b/src/can1/f6r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7681fd69cfdae51cc799a597b5a995a73bfcabe9 --- /dev/null +++ b/src/can1/f6r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F6R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f6r2/mod.rs b/src/can1/f6r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9289c86801bc8baaf13711377b95b096f9253c7d --- /dev/null +++ b/src/can1/f6r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F6R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f7r1/mod.rs b/src/can1/f7r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7ad57bedbc9f7da60c9992c660c5ce54a86bc5f9 --- /dev/null +++ b/src/can1/f7r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F7R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f7r2/mod.rs b/src/can1/f7r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fdfcf2472f86369f4516dd5deff9e34fce45398f --- /dev/null +++ b/src/can1/f7r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F7R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f8r1/mod.rs b/src/can1/f8r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7ffdfd8dfb0a4c69016ac18d54d5ce5f4173a0b0 --- /dev/null +++ b/src/can1/f8r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F8R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f8r2/mod.rs b/src/can1/f8r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2f26466a5e5a42476083b398d31d8d58b070ca03 --- /dev/null +++ b/src/can1/f8r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F8R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f9r1/mod.rs b/src/can1/f9r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..756239bd5fb68104d23c50e4f4f4b0e784924011 --- /dev/null +++ b/src/can1/f9r1/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F9R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/f9r2/mod.rs b/src/can1/f9r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7b375cc6f522bd8566b08c9e1472a26eb7bd439a --- /dev/null +++ b/src/can1/f9r2/mod.rs @@ -0,0 +1,1952 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::F9R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FB0R { + bits: bool, +} +impl FB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB1R { + bits: bool, +} +impl FB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB2R { + bits: bool, +} +impl FB2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB3R { + bits: bool, +} +impl FB3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB4R { + bits: bool, +} +impl FB4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB5R { + bits: bool, +} +impl FB5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB6R { + bits: bool, +} +impl FB6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB7R { + bits: bool, +} +impl FB7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB8R { + bits: bool, +} +impl FB8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB9R { + bits: bool, +} +impl FB9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB10R { + bits: bool, +} +impl FB10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB11R { + bits: bool, +} +impl FB11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB12R { + bits: bool, +} +impl FB12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB13R { + bits: bool, +} +impl FB13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB14R { + bits: bool, +} +impl FB14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB15R { + bits: bool, +} +impl FB15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB16R { + bits: bool, +} +impl FB16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB17R { + bits: bool, +} +impl FB17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB18R { + bits: bool, +} +impl FB18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB19R { + bits: bool, +} +impl FB19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB20R { + bits: bool, +} +impl FB20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB21R { + bits: bool, +} +impl FB21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB22R { + bits: bool, +} +impl FB22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB23R { + bits: bool, +} +impl FB23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB24R { + bits: bool, +} +impl FB24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB25R { + bits: bool, +} +impl FB25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB26R { + bits: bool, +} +impl FB26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB27R { + bits: bool, +} +impl FB27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB28R { + bits: bool, +} +impl FB28R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB29R { + bits: bool, +} +impl FB29R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB30R { + bits: bool, +} +impl FB30R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FB31R { + bits: bool, +} +impl FB31R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FB0W<'a> { + w: &'a mut W, +} +impl<'a> _FB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB1W<'a> { + w: &'a mut W, +} +impl<'a> _FB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB2W<'a> { + w: &'a mut W, +} +impl<'a> _FB2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB3W<'a> { + w: &'a mut W, +} +impl<'a> _FB3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB4W<'a> { + w: &'a mut W, +} +impl<'a> _FB4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB5W<'a> { + w: &'a mut W, +} +impl<'a> _FB5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB6W<'a> { + w: &'a mut W, +} +impl<'a> _FB6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB7W<'a> { + w: &'a mut W, +} +impl<'a> _FB7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB8W<'a> { + w: &'a mut W, +} +impl<'a> _FB8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB9W<'a> { + w: &'a mut W, +} +impl<'a> _FB9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB10W<'a> { + w: &'a mut W, +} +impl<'a> _FB10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB11W<'a> { + w: &'a mut W, +} +impl<'a> _FB11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB12W<'a> { + w: &'a mut W, +} +impl<'a> _FB12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB13W<'a> { + w: &'a mut W, +} +impl<'a> _FB13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB14W<'a> { + w: &'a mut W, +} +impl<'a> _FB14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB15W<'a> { + w: &'a mut W, +} +impl<'a> _FB15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB16W<'a> { + w: &'a mut W, +} +impl<'a> _FB16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB17W<'a> { + w: &'a mut W, +} +impl<'a> _FB17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB18W<'a> { + w: &'a mut W, +} +impl<'a> _FB18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB19W<'a> { + w: &'a mut W, +} +impl<'a> _FB19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB20W<'a> { + w: &'a mut W, +} +impl<'a> _FB20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB21W<'a> { + w: &'a mut W, +} +impl<'a> _FB21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB22W<'a> { + w: &'a mut W, +} +impl<'a> _FB22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB23W<'a> { + w: &'a mut W, +} +impl<'a> _FB23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB24W<'a> { + w: &'a mut W, +} +impl<'a> _FB24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB25W<'a> { + w: &'a mut W, +} +impl<'a> _FB25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB26W<'a> { + w: &'a mut W, +} +impl<'a> _FB26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB27W<'a> { + w: &'a mut W, +} +impl<'a> _FB27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB28W<'a> { + w: &'a mut W, +} +impl<'a> _FB28W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB29W<'a> { + w: &'a mut W, +} +impl<'a> _FB29W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB30W<'a> { + w: &'a mut W, +} +impl<'a> _FB30W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FB31W<'a> { + w: &'a mut W, +} +impl<'a> _FB31W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&self) -> FB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB0R { bits } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&self) -> FB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB1R { bits } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&self) -> FB2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB2R { bits } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&self) -> FB3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB3R { bits } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&self) -> FB4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB4R { bits } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&self) -> FB5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB5R { bits } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&self) -> FB6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB6R { bits } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&self) -> FB7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB7R { bits } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&self) -> FB8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB8R { bits } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&self) -> FB9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB9R { bits } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&self) -> FB10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB10R { bits } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&self) -> FB11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB11R { bits } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&self) -> FB12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB12R { bits } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&self) -> FB13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB13R { bits } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&self) -> FB14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB14R { bits } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&self) -> FB15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB15R { bits } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&self) -> FB16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB16R { bits } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&self) -> FB17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB17R { bits } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&self) -> FB18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB18R { bits } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&self) -> FB19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB19R { bits } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&self) -> FB20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB20R { bits } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&self) -> FB21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB21R { bits } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&self) -> FB22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB22R { bits } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&self) -> FB23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB23R { bits } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&self) -> FB24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB24R { bits } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&self) -> FB25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB25R { bits } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&self) -> FB26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB26R { bits } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&self) -> FB27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB27R { bits } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&self) -> FB28R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB28R { bits } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&self) -> FB29R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB29R { bits } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&self) -> FB30R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB30R { bits } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&self) -> FB31R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FB31R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter bits"] + #[inline] + pub fn fb0(&mut self) -> _FB0W { + _FB0W { w: self } + } + #[doc = "Bit 1 - Filter bits"] + #[inline] + pub fn fb1(&mut self) -> _FB1W { + _FB1W { w: self } + } + #[doc = "Bit 2 - Filter bits"] + #[inline] + pub fn fb2(&mut self) -> _FB2W { + _FB2W { w: self } + } + #[doc = "Bit 3 - Filter bits"] + #[inline] + pub fn fb3(&mut self) -> _FB3W { + _FB3W { w: self } + } + #[doc = "Bit 4 - Filter bits"] + #[inline] + pub fn fb4(&mut self) -> _FB4W { + _FB4W { w: self } + } + #[doc = "Bit 5 - Filter bits"] + #[inline] + pub fn fb5(&mut self) -> _FB5W { + _FB5W { w: self } + } + #[doc = "Bit 6 - Filter bits"] + #[inline] + pub fn fb6(&mut self) -> _FB6W { + _FB6W { w: self } + } + #[doc = "Bit 7 - Filter bits"] + #[inline] + pub fn fb7(&mut self) -> _FB7W { + _FB7W { w: self } + } + #[doc = "Bit 8 - Filter bits"] + #[inline] + pub fn fb8(&mut self) -> _FB8W { + _FB8W { w: self } + } + #[doc = "Bit 9 - Filter bits"] + #[inline] + pub fn fb9(&mut self) -> _FB9W { + _FB9W { w: self } + } + #[doc = "Bit 10 - Filter bits"] + #[inline] + pub fn fb10(&mut self) -> _FB10W { + _FB10W { w: self } + } + #[doc = "Bit 11 - Filter bits"] + #[inline] + pub fn fb11(&mut self) -> _FB11W { + _FB11W { w: self } + } + #[doc = "Bit 12 - Filter bits"] + #[inline] + pub fn fb12(&mut self) -> _FB12W { + _FB12W { w: self } + } + #[doc = "Bit 13 - Filter bits"] + #[inline] + pub fn fb13(&mut self) -> _FB13W { + _FB13W { w: self } + } + #[doc = "Bit 14 - Filter bits"] + #[inline] + pub fn fb14(&mut self) -> _FB14W { + _FB14W { w: self } + } + #[doc = "Bit 15 - Filter bits"] + #[inline] + pub fn fb15(&mut self) -> _FB15W { + _FB15W { w: self } + } + #[doc = "Bit 16 - Filter bits"] + #[inline] + pub fn fb16(&mut self) -> _FB16W { + _FB16W { w: self } + } + #[doc = "Bit 17 - Filter bits"] + #[inline] + pub fn fb17(&mut self) -> _FB17W { + _FB17W { w: self } + } + #[doc = "Bit 18 - Filter bits"] + #[inline] + pub fn fb18(&mut self) -> _FB18W { + _FB18W { w: self } + } + #[doc = "Bit 19 - Filter bits"] + #[inline] + pub fn fb19(&mut self) -> _FB19W { + _FB19W { w: self } + } + #[doc = "Bit 20 - Filter bits"] + #[inline] + pub fn fb20(&mut self) -> _FB20W { + _FB20W { w: self } + } + #[doc = "Bit 21 - Filter bits"] + #[inline] + pub fn fb21(&mut self) -> _FB21W { + _FB21W { w: self } + } + #[doc = "Bit 22 - Filter bits"] + #[inline] + pub fn fb22(&mut self) -> _FB22W { + _FB22W { w: self } + } + #[doc = "Bit 23 - Filter bits"] + #[inline] + pub fn fb23(&mut self) -> _FB23W { + _FB23W { w: self } + } + #[doc = "Bit 24 - Filter bits"] + #[inline] + pub fn fb24(&mut self) -> _FB24W { + _FB24W { w: self } + } + #[doc = "Bit 25 - Filter bits"] + #[inline] + pub fn fb25(&mut self) -> _FB25W { + _FB25W { w: self } + } + #[doc = "Bit 26 - Filter bits"] + #[inline] + pub fn fb26(&mut self) -> _FB26W { + _FB26W { w: self } + } + #[doc = "Bit 27 - Filter bits"] + #[inline] + pub fn fb27(&mut self) -> _FB27W { + _FB27W { w: self } + } + #[doc = "Bit 28 - Filter bits"] + #[inline] + pub fn fb28(&mut self) -> _FB28W { + _FB28W { w: self } + } + #[doc = "Bit 29 - Filter bits"] + #[inline] + pub fn fb29(&mut self) -> _FB29W { + _FB29W { w: self } + } + #[doc = "Bit 30 - Filter bits"] + #[inline] + pub fn fb30(&mut self) -> _FB30W { + _FB30W { w: self } + } + #[doc = "Bit 31 - Filter bits"] + #[inline] + pub fn fb31(&mut self) -> _FB31W { + _FB31W { w: self } + } +} diff --git a/src/can1/fa1r/mod.rs b/src/can1/fa1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c3b07077dd7e5e195d79703e60a304ed83c4a69b --- /dev/null +++ b/src/can1/fa1r/mod.rs @@ -0,0 +1,1716 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FA1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FACT0R { + bits: bool, +} +impl FACT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT1R { + bits: bool, +} +impl FACT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT2R { + bits: bool, +} +impl FACT2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT3R { + bits: bool, +} +impl FACT3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT4R { + bits: bool, +} +impl FACT4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT5R { + bits: bool, +} +impl FACT5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT6R { + bits: bool, +} +impl FACT6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT7R { + bits: bool, +} +impl FACT7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT8R { + bits: bool, +} +impl FACT8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT9R { + bits: bool, +} +impl FACT9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT10R { + bits: bool, +} +impl FACT10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT11R { + bits: bool, +} +impl FACT11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT12R { + bits: bool, +} +impl FACT12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT13R { + bits: bool, +} +impl FACT13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT14R { + bits: bool, +} +impl FACT14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT15R { + bits: bool, +} +impl FACT15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT16R { + bits: bool, +} +impl FACT16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT17R { + bits: bool, +} +impl FACT17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT18R { + bits: bool, +} +impl FACT18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT19R { + bits: bool, +} +impl FACT19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT20R { + bits: bool, +} +impl FACT20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT21R { + bits: bool, +} +impl FACT21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT22R { + bits: bool, +} +impl FACT22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT23R { + bits: bool, +} +impl FACT23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT24R { + bits: bool, +} +impl FACT24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT25R { + bits: bool, +} +impl FACT25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT26R { + bits: bool, +} +impl FACT26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACT27R { + bits: bool, +} +impl FACT27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FACT0W<'a> { + w: &'a mut W, +} +impl<'a> _FACT0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT1W<'a> { + w: &'a mut W, +} +impl<'a> _FACT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT2W<'a> { + w: &'a mut W, +} +impl<'a> _FACT2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT3W<'a> { + w: &'a mut W, +} +impl<'a> _FACT3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT4W<'a> { + w: &'a mut W, +} +impl<'a> _FACT4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT5W<'a> { + w: &'a mut W, +} +impl<'a> _FACT5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT6W<'a> { + w: &'a mut W, +} +impl<'a> _FACT6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT7W<'a> { + w: &'a mut W, +} +impl<'a> _FACT7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT8W<'a> { + w: &'a mut W, +} +impl<'a> _FACT8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT9W<'a> { + w: &'a mut W, +} +impl<'a> _FACT9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT10W<'a> { + w: &'a mut W, +} +impl<'a> _FACT10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT11W<'a> { + w: &'a mut W, +} +impl<'a> _FACT11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT12W<'a> { + w: &'a mut W, +} +impl<'a> _FACT12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT13W<'a> { + w: &'a mut W, +} +impl<'a> _FACT13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT14W<'a> { + w: &'a mut W, +} +impl<'a> _FACT14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT15W<'a> { + w: &'a mut W, +} +impl<'a> _FACT15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT16W<'a> { + w: &'a mut W, +} +impl<'a> _FACT16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT17W<'a> { + w: &'a mut W, +} +impl<'a> _FACT17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT18W<'a> { + w: &'a mut W, +} +impl<'a> _FACT18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT19W<'a> { + w: &'a mut W, +} +impl<'a> _FACT19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT20W<'a> { + w: &'a mut W, +} +impl<'a> _FACT20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT21W<'a> { + w: &'a mut W, +} +impl<'a> _FACT21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT22W<'a> { + w: &'a mut W, +} +impl<'a> _FACT22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT23W<'a> { + w: &'a mut W, +} +impl<'a> _FACT23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT24W<'a> { + w: &'a mut W, +} +impl<'a> _FACT24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT25W<'a> { + w: &'a mut W, +} +impl<'a> _FACT25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT26W<'a> { + w: &'a mut W, +} +impl<'a> _FACT26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACT27W<'a> { + w: &'a mut W, +} +impl<'a> _FACT27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter active"] + #[inline] + pub fn fact0(&self) -> FACT0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT0R { bits } + } + #[doc = "Bit 1 - Filter active"] + #[inline] + pub fn fact1(&self) -> FACT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT1R { bits } + } + #[doc = "Bit 2 - Filter active"] + #[inline] + pub fn fact2(&self) -> FACT2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT2R { bits } + } + #[doc = "Bit 3 - Filter active"] + #[inline] + pub fn fact3(&self) -> FACT3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT3R { bits } + } + #[doc = "Bit 4 - Filter active"] + #[inline] + pub fn fact4(&self) -> FACT4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT4R { bits } + } + #[doc = "Bit 5 - Filter active"] + #[inline] + pub fn fact5(&self) -> FACT5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT5R { bits } + } + #[doc = "Bit 6 - Filter active"] + #[inline] + pub fn fact6(&self) -> FACT6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT6R { bits } + } + #[doc = "Bit 7 - Filter active"] + #[inline] + pub fn fact7(&self) -> FACT7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT7R { bits } + } + #[doc = "Bit 8 - Filter active"] + #[inline] + pub fn fact8(&self) -> FACT8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT8R { bits } + } + #[doc = "Bit 9 - Filter active"] + #[inline] + pub fn fact9(&self) -> FACT9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT9R { bits } + } + #[doc = "Bit 10 - Filter active"] + #[inline] + pub fn fact10(&self) -> FACT10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT10R { bits } + } + #[doc = "Bit 11 - Filter active"] + #[inline] + pub fn fact11(&self) -> FACT11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT11R { bits } + } + #[doc = "Bit 12 - Filter active"] + #[inline] + pub fn fact12(&self) -> FACT12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT12R { bits } + } + #[doc = "Bit 13 - Filter active"] + #[inline] + pub fn fact13(&self) -> FACT13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT13R { bits } + } + #[doc = "Bit 14 - Filter active"] + #[inline] + pub fn fact14(&self) -> FACT14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT14R { bits } + } + #[doc = "Bit 15 - Filter active"] + #[inline] + pub fn fact15(&self) -> FACT15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT15R { bits } + } + #[doc = "Bit 16 - Filter active"] + #[inline] + pub fn fact16(&self) -> FACT16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT16R { bits } + } + #[doc = "Bit 17 - Filter active"] + #[inline] + pub fn fact17(&self) -> FACT17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT17R { bits } + } + #[doc = "Bit 18 - Filter active"] + #[inline] + pub fn fact18(&self) -> FACT18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT18R { bits } + } + #[doc = "Bit 19 - Filter active"] + #[inline] + pub fn fact19(&self) -> FACT19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT19R { bits } + } + #[doc = "Bit 20 - Filter active"] + #[inline] + pub fn fact20(&self) -> FACT20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT20R { bits } + } + #[doc = "Bit 21 - Filter active"] + #[inline] + pub fn fact21(&self) -> FACT21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT21R { bits } + } + #[doc = "Bit 22 - Filter active"] + #[inline] + pub fn fact22(&self) -> FACT22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT22R { bits } + } + #[doc = "Bit 23 - Filter active"] + #[inline] + pub fn fact23(&self) -> FACT23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT23R { bits } + } + #[doc = "Bit 24 - Filter active"] + #[inline] + pub fn fact24(&self) -> FACT24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT24R { bits } + } + #[doc = "Bit 25 - Filter active"] + #[inline] + pub fn fact25(&self) -> FACT25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT25R { bits } + } + #[doc = "Bit 26 - Filter active"] + #[inline] + pub fn fact26(&self) -> FACT26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT26R { bits } + } + #[doc = "Bit 27 - Filter active"] + #[inline] + pub fn fact27(&self) -> FACT27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACT27R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter active"] + #[inline] + pub fn fact0(&mut self) -> _FACT0W { + _FACT0W { w: self } + } + #[doc = "Bit 1 - Filter active"] + #[inline] + pub fn fact1(&mut self) -> _FACT1W { + _FACT1W { w: self } + } + #[doc = "Bit 2 - Filter active"] + #[inline] + pub fn fact2(&mut self) -> _FACT2W { + _FACT2W { w: self } + } + #[doc = "Bit 3 - Filter active"] + #[inline] + pub fn fact3(&mut self) -> _FACT3W { + _FACT3W { w: self } + } + #[doc = "Bit 4 - Filter active"] + #[inline] + pub fn fact4(&mut self) -> _FACT4W { + _FACT4W { w: self } + } + #[doc = "Bit 5 - Filter active"] + #[inline] + pub fn fact5(&mut self) -> _FACT5W { + _FACT5W { w: self } + } + #[doc = "Bit 6 - Filter active"] + #[inline] + pub fn fact6(&mut self) -> _FACT6W { + _FACT6W { w: self } + } + #[doc = "Bit 7 - Filter active"] + #[inline] + pub fn fact7(&mut self) -> _FACT7W { + _FACT7W { w: self } + } + #[doc = "Bit 8 - Filter active"] + #[inline] + pub fn fact8(&mut self) -> _FACT8W { + _FACT8W { w: self } + } + #[doc = "Bit 9 - Filter active"] + #[inline] + pub fn fact9(&mut self) -> _FACT9W { + _FACT9W { w: self } + } + #[doc = "Bit 10 - Filter active"] + #[inline] + pub fn fact10(&mut self) -> _FACT10W { + _FACT10W { w: self } + } + #[doc = "Bit 11 - Filter active"] + #[inline] + pub fn fact11(&mut self) -> _FACT11W { + _FACT11W { w: self } + } + #[doc = "Bit 12 - Filter active"] + #[inline] + pub fn fact12(&mut self) -> _FACT12W { + _FACT12W { w: self } + } + #[doc = "Bit 13 - Filter active"] + #[inline] + pub fn fact13(&mut self) -> _FACT13W { + _FACT13W { w: self } + } + #[doc = "Bit 14 - Filter active"] + #[inline] + pub fn fact14(&mut self) -> _FACT14W { + _FACT14W { w: self } + } + #[doc = "Bit 15 - Filter active"] + #[inline] + pub fn fact15(&mut self) -> _FACT15W { + _FACT15W { w: self } + } + #[doc = "Bit 16 - Filter active"] + #[inline] + pub fn fact16(&mut self) -> _FACT16W { + _FACT16W { w: self } + } + #[doc = "Bit 17 - Filter active"] + #[inline] + pub fn fact17(&mut self) -> _FACT17W { + _FACT17W { w: self } + } + #[doc = "Bit 18 - Filter active"] + #[inline] + pub fn fact18(&mut self) -> _FACT18W { + _FACT18W { w: self } + } + #[doc = "Bit 19 - Filter active"] + #[inline] + pub fn fact19(&mut self) -> _FACT19W { + _FACT19W { w: self } + } + #[doc = "Bit 20 - Filter active"] + #[inline] + pub fn fact20(&mut self) -> _FACT20W { + _FACT20W { w: self } + } + #[doc = "Bit 21 - Filter active"] + #[inline] + pub fn fact21(&mut self) -> _FACT21W { + _FACT21W { w: self } + } + #[doc = "Bit 22 - Filter active"] + #[inline] + pub fn fact22(&mut self) -> _FACT22W { + _FACT22W { w: self } + } + #[doc = "Bit 23 - Filter active"] + #[inline] + pub fn fact23(&mut self) -> _FACT23W { + _FACT23W { w: self } + } + #[doc = "Bit 24 - Filter active"] + #[inline] + pub fn fact24(&mut self) -> _FACT24W { + _FACT24W { w: self } + } + #[doc = "Bit 25 - Filter active"] + #[inline] + pub fn fact25(&mut self) -> _FACT25W { + _FACT25W { w: self } + } + #[doc = "Bit 26 - Filter active"] + #[inline] + pub fn fact26(&mut self) -> _FACT26W { + _FACT26W { w: self } + } + #[doc = "Bit 27 - Filter active"] + #[inline] + pub fn fact27(&mut self) -> _FACT27W { + _FACT27W { w: self } + } +} diff --git a/src/can1/ffa1r/mod.rs b/src/can1/ffa1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d9b75234d7901aa829c9a5abfa73c0ef3ceb18f1 --- /dev/null +++ b/src/can1/ffa1r/mod.rs @@ -0,0 +1,1716 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FFA1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FFA0R { + bits: bool, +} +impl FFA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA1R { + bits: bool, +} +impl FFA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA2R { + bits: bool, +} +impl FFA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA3R { + bits: bool, +} +impl FFA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA4R { + bits: bool, +} +impl FFA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA5R { + bits: bool, +} +impl FFA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA6R { + bits: bool, +} +impl FFA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA7R { + bits: bool, +} +impl FFA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA8R { + bits: bool, +} +impl FFA8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA9R { + bits: bool, +} +impl FFA9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA10R { + bits: bool, +} +impl FFA10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA11R { + bits: bool, +} +impl FFA11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA12R { + bits: bool, +} +impl FFA12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA13R { + bits: bool, +} +impl FFA13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA14R { + bits: bool, +} +impl FFA14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA15R { + bits: bool, +} +impl FFA15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA16R { + bits: bool, +} +impl FFA16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA17R { + bits: bool, +} +impl FFA17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA18R { + bits: bool, +} +impl FFA18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA19R { + bits: bool, +} +impl FFA19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA20R { + bits: bool, +} +impl FFA20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA21R { + bits: bool, +} +impl FFA21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA22R { + bits: bool, +} +impl FFA22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA23R { + bits: bool, +} +impl FFA23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA24R { + bits: bool, +} +impl FFA24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA25R { + bits: bool, +} +impl FFA25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA26R { + bits: bool, +} +impl FFA26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFA27R { + bits: bool, +} +impl FFA27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FFA0W<'a> { + w: &'a mut W, +} +impl<'a> _FFA0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA1W<'a> { + w: &'a mut W, +} +impl<'a> _FFA1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA2W<'a> { + w: &'a mut W, +} +impl<'a> _FFA2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA3W<'a> { + w: &'a mut W, +} +impl<'a> _FFA3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA4W<'a> { + w: &'a mut W, +} +impl<'a> _FFA4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA5W<'a> { + w: &'a mut W, +} +impl<'a> _FFA5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA6W<'a> { + w: &'a mut W, +} +impl<'a> _FFA6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA7W<'a> { + w: &'a mut W, +} +impl<'a> _FFA7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA8W<'a> { + w: &'a mut W, +} +impl<'a> _FFA8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA9W<'a> { + w: &'a mut W, +} +impl<'a> _FFA9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA10W<'a> { + w: &'a mut W, +} +impl<'a> _FFA10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA11W<'a> { + w: &'a mut W, +} +impl<'a> _FFA11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA12W<'a> { + w: &'a mut W, +} +impl<'a> _FFA12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA13W<'a> { + w: &'a mut W, +} +impl<'a> _FFA13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA14W<'a> { + w: &'a mut W, +} +impl<'a> _FFA14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA15W<'a> { + w: &'a mut W, +} +impl<'a> _FFA15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA16W<'a> { + w: &'a mut W, +} +impl<'a> _FFA16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA17W<'a> { + w: &'a mut W, +} +impl<'a> _FFA17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA18W<'a> { + w: &'a mut W, +} +impl<'a> _FFA18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA19W<'a> { + w: &'a mut W, +} +impl<'a> _FFA19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA20W<'a> { + w: &'a mut W, +} +impl<'a> _FFA20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA21W<'a> { + w: &'a mut W, +} +impl<'a> _FFA21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA22W<'a> { + w: &'a mut W, +} +impl<'a> _FFA22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA23W<'a> { + w: &'a mut W, +} +impl<'a> _FFA23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA24W<'a> { + w: &'a mut W, +} +impl<'a> _FFA24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA25W<'a> { + w: &'a mut W, +} +impl<'a> _FFA25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA26W<'a> { + w: &'a mut W, +} +impl<'a> _FFA26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFA27W<'a> { + w: &'a mut W, +} +impl<'a> _FFA27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter FIFO assignment for filter 0"] + #[inline] + pub fn ffa0(&self) -> FFA0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA0R { bits } + } + #[doc = "Bit 1 - Filter FIFO assignment for filter 1"] + #[inline] + pub fn ffa1(&self) -> FFA1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA1R { bits } + } + #[doc = "Bit 2 - Filter FIFO assignment for filter 2"] + #[inline] + pub fn ffa2(&self) -> FFA2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA2R { bits } + } + #[doc = "Bit 3 - Filter FIFO assignment for filter 3"] + #[inline] + pub fn ffa3(&self) -> FFA3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA3R { bits } + } + #[doc = "Bit 4 - Filter FIFO assignment for filter 4"] + #[inline] + pub fn ffa4(&self) -> FFA4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA4R { bits } + } + #[doc = "Bit 5 - Filter FIFO assignment for filter 5"] + #[inline] + pub fn ffa5(&self) -> FFA5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA5R { bits } + } + #[doc = "Bit 6 - Filter FIFO assignment for filter 6"] + #[inline] + pub fn ffa6(&self) -> FFA6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA6R { bits } + } + #[doc = "Bit 7 - Filter FIFO assignment for filter 7"] + #[inline] + pub fn ffa7(&self) -> FFA7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA7R { bits } + } + #[doc = "Bit 8 - Filter FIFO assignment for filter 8"] + #[inline] + pub fn ffa8(&self) -> FFA8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA8R { bits } + } + #[doc = "Bit 9 - Filter FIFO assignment for filter 9"] + #[inline] + pub fn ffa9(&self) -> FFA9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA9R { bits } + } + #[doc = "Bit 10 - Filter FIFO assignment for filter 10"] + #[inline] + pub fn ffa10(&self) -> FFA10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA10R { bits } + } + #[doc = "Bit 11 - Filter FIFO assignment for filter 11"] + #[inline] + pub fn ffa11(&self) -> FFA11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA11R { bits } + } + #[doc = "Bit 12 - Filter FIFO assignment for filter 12"] + #[inline] + pub fn ffa12(&self) -> FFA12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA12R { bits } + } + #[doc = "Bit 13 - Filter FIFO assignment for filter 13"] + #[inline] + pub fn ffa13(&self) -> FFA13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA13R { bits } + } + #[doc = "Bit 14 - Filter FIFO assignment for filter 14"] + #[inline] + pub fn ffa14(&self) -> FFA14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA14R { bits } + } + #[doc = "Bit 15 - Filter FIFO assignment for filter 15"] + #[inline] + pub fn ffa15(&self) -> FFA15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA15R { bits } + } + #[doc = "Bit 16 - Filter FIFO assignment for filter 16"] + #[inline] + pub fn ffa16(&self) -> FFA16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA16R { bits } + } + #[doc = "Bit 17 - Filter FIFO assignment for filter 17"] + #[inline] + pub fn ffa17(&self) -> FFA17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA17R { bits } + } + #[doc = "Bit 18 - Filter FIFO assignment for filter 18"] + #[inline] + pub fn ffa18(&self) -> FFA18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA18R { bits } + } + #[doc = "Bit 19 - Filter FIFO assignment for filter 19"] + #[inline] + pub fn ffa19(&self) -> FFA19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA19R { bits } + } + #[doc = "Bit 20 - Filter FIFO assignment for filter 20"] + #[inline] + pub fn ffa20(&self) -> FFA20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA20R { bits } + } + #[doc = "Bit 21 - Filter FIFO assignment for filter 21"] + #[inline] + pub fn ffa21(&self) -> FFA21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA21R { bits } + } + #[doc = "Bit 22 - Filter FIFO assignment for filter 22"] + #[inline] + pub fn ffa22(&self) -> FFA22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA22R { bits } + } + #[doc = "Bit 23 - Filter FIFO assignment for filter 23"] + #[inline] + pub fn ffa23(&self) -> FFA23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA23R { bits } + } + #[doc = "Bit 24 - Filter FIFO assignment for filter 24"] + #[inline] + pub fn ffa24(&self) -> FFA24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA24R { bits } + } + #[doc = "Bit 25 - Filter FIFO assignment for filter 25"] + #[inline] + pub fn ffa25(&self) -> FFA25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA25R { bits } + } + #[doc = "Bit 26 - Filter FIFO assignment for filter 26"] + #[inline] + pub fn ffa26(&self) -> FFA26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA26R { bits } + } + #[doc = "Bit 27 - Filter FIFO assignment for filter 27"] + #[inline] + pub fn ffa27(&self) -> FFA27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFA27R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter FIFO assignment for filter 0"] + #[inline] + pub fn ffa0(&mut self) -> _FFA0W { + _FFA0W { w: self } + } + #[doc = "Bit 1 - Filter FIFO assignment for filter 1"] + #[inline] + pub fn ffa1(&mut self) -> _FFA1W { + _FFA1W { w: self } + } + #[doc = "Bit 2 - Filter FIFO assignment for filter 2"] + #[inline] + pub fn ffa2(&mut self) -> _FFA2W { + _FFA2W { w: self } + } + #[doc = "Bit 3 - Filter FIFO assignment for filter 3"] + #[inline] + pub fn ffa3(&mut self) -> _FFA3W { + _FFA3W { w: self } + } + #[doc = "Bit 4 - Filter FIFO assignment for filter 4"] + #[inline] + pub fn ffa4(&mut self) -> _FFA4W { + _FFA4W { w: self } + } + #[doc = "Bit 5 - Filter FIFO assignment for filter 5"] + #[inline] + pub fn ffa5(&mut self) -> _FFA5W { + _FFA5W { w: self } + } + #[doc = "Bit 6 - Filter FIFO assignment for filter 6"] + #[inline] + pub fn ffa6(&mut self) -> _FFA6W { + _FFA6W { w: self } + } + #[doc = "Bit 7 - Filter FIFO assignment for filter 7"] + #[inline] + pub fn ffa7(&mut self) -> _FFA7W { + _FFA7W { w: self } + } + #[doc = "Bit 8 - Filter FIFO assignment for filter 8"] + #[inline] + pub fn ffa8(&mut self) -> _FFA8W { + _FFA8W { w: self } + } + #[doc = "Bit 9 - Filter FIFO assignment for filter 9"] + #[inline] + pub fn ffa9(&mut self) -> _FFA9W { + _FFA9W { w: self } + } + #[doc = "Bit 10 - Filter FIFO assignment for filter 10"] + #[inline] + pub fn ffa10(&mut self) -> _FFA10W { + _FFA10W { w: self } + } + #[doc = "Bit 11 - Filter FIFO assignment for filter 11"] + #[inline] + pub fn ffa11(&mut self) -> _FFA11W { + _FFA11W { w: self } + } + #[doc = "Bit 12 - Filter FIFO assignment for filter 12"] + #[inline] + pub fn ffa12(&mut self) -> _FFA12W { + _FFA12W { w: self } + } + #[doc = "Bit 13 - Filter FIFO assignment for filter 13"] + #[inline] + pub fn ffa13(&mut self) -> _FFA13W { + _FFA13W { w: self } + } + #[doc = "Bit 14 - Filter FIFO assignment for filter 14"] + #[inline] + pub fn ffa14(&mut self) -> _FFA14W { + _FFA14W { w: self } + } + #[doc = "Bit 15 - Filter FIFO assignment for filter 15"] + #[inline] + pub fn ffa15(&mut self) -> _FFA15W { + _FFA15W { w: self } + } + #[doc = "Bit 16 - Filter FIFO assignment for filter 16"] + #[inline] + pub fn ffa16(&mut self) -> _FFA16W { + _FFA16W { w: self } + } + #[doc = "Bit 17 - Filter FIFO assignment for filter 17"] + #[inline] + pub fn ffa17(&mut self) -> _FFA17W { + _FFA17W { w: self } + } + #[doc = "Bit 18 - Filter FIFO assignment for filter 18"] + #[inline] + pub fn ffa18(&mut self) -> _FFA18W { + _FFA18W { w: self } + } + #[doc = "Bit 19 - Filter FIFO assignment for filter 19"] + #[inline] + pub fn ffa19(&mut self) -> _FFA19W { + _FFA19W { w: self } + } + #[doc = "Bit 20 - Filter FIFO assignment for filter 20"] + #[inline] + pub fn ffa20(&mut self) -> _FFA20W { + _FFA20W { w: self } + } + #[doc = "Bit 21 - Filter FIFO assignment for filter 21"] + #[inline] + pub fn ffa21(&mut self) -> _FFA21W { + _FFA21W { w: self } + } + #[doc = "Bit 22 - Filter FIFO assignment for filter 22"] + #[inline] + pub fn ffa22(&mut self) -> _FFA22W { + _FFA22W { w: self } + } + #[doc = "Bit 23 - Filter FIFO assignment for filter 23"] + #[inline] + pub fn ffa23(&mut self) -> _FFA23W { + _FFA23W { w: self } + } + #[doc = "Bit 24 - Filter FIFO assignment for filter 24"] + #[inline] + pub fn ffa24(&mut self) -> _FFA24W { + _FFA24W { w: self } + } + #[doc = "Bit 25 - Filter FIFO assignment for filter 25"] + #[inline] + pub fn ffa25(&mut self) -> _FFA25W { + _FFA25W { w: self } + } + #[doc = "Bit 26 - Filter FIFO assignment for filter 26"] + #[inline] + pub fn ffa26(&mut self) -> _FFA26W { + _FFA26W { w: self } + } + #[doc = "Bit 27 - Filter FIFO assignment for filter 27"] + #[inline] + pub fn ffa27(&mut self) -> _FFA27W { + _FFA27W { w: self } + } +} diff --git a/src/can1/fm1r/mod.rs b/src/can1/fm1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b8fe984fb0d0eaa2d2e3072fca5ee90f2a51c8ee --- /dev/null +++ b/src/can1/fm1r/mod.rs @@ -0,0 +1,1716 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FM1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FBM0R { + bits: bool, +} +impl FBM0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM1R { + bits: bool, +} +impl FBM1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM2R { + bits: bool, +} +impl FBM2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM3R { + bits: bool, +} +impl FBM3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM4R { + bits: bool, +} +impl FBM4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM5R { + bits: bool, +} +impl FBM5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM6R { + bits: bool, +} +impl FBM6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM7R { + bits: bool, +} +impl FBM7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM8R { + bits: bool, +} +impl FBM8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM9R { + bits: bool, +} +impl FBM9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM10R { + bits: bool, +} +impl FBM10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM11R { + bits: bool, +} +impl FBM11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM12R { + bits: bool, +} +impl FBM12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM13R { + bits: bool, +} +impl FBM13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM14R { + bits: bool, +} +impl FBM14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM15R { + bits: bool, +} +impl FBM15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM16R { + bits: bool, +} +impl FBM16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM17R { + bits: bool, +} +impl FBM17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM18R { + bits: bool, +} +impl FBM18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM19R { + bits: bool, +} +impl FBM19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM20R { + bits: bool, +} +impl FBM20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM21R { + bits: bool, +} +impl FBM21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM22R { + bits: bool, +} +impl FBM22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM23R { + bits: bool, +} +impl FBM23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM24R { + bits: bool, +} +impl FBM24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM25R { + bits: bool, +} +impl FBM25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM26R { + bits: bool, +} +impl FBM26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FBM27R { + bits: bool, +} +impl FBM27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FBM0W<'a> { + w: &'a mut W, +} +impl<'a> _FBM0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM1W<'a> { + w: &'a mut W, +} +impl<'a> _FBM1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM2W<'a> { + w: &'a mut W, +} +impl<'a> _FBM2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM3W<'a> { + w: &'a mut W, +} +impl<'a> _FBM3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM4W<'a> { + w: &'a mut W, +} +impl<'a> _FBM4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM5W<'a> { + w: &'a mut W, +} +impl<'a> _FBM5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM6W<'a> { + w: &'a mut W, +} +impl<'a> _FBM6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM7W<'a> { + w: &'a mut W, +} +impl<'a> _FBM7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM8W<'a> { + w: &'a mut W, +} +impl<'a> _FBM8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM9W<'a> { + w: &'a mut W, +} +impl<'a> _FBM9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM10W<'a> { + w: &'a mut W, +} +impl<'a> _FBM10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM11W<'a> { + w: &'a mut W, +} +impl<'a> _FBM11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM12W<'a> { + w: &'a mut W, +} +impl<'a> _FBM12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM13W<'a> { + w: &'a mut W, +} +impl<'a> _FBM13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM14W<'a> { + w: &'a mut W, +} +impl<'a> _FBM14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM15W<'a> { + w: &'a mut W, +} +impl<'a> _FBM15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM16W<'a> { + w: &'a mut W, +} +impl<'a> _FBM16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM17W<'a> { + w: &'a mut W, +} +impl<'a> _FBM17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM18W<'a> { + w: &'a mut W, +} +impl<'a> _FBM18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM19W<'a> { + w: &'a mut W, +} +impl<'a> _FBM19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM20W<'a> { + w: &'a mut W, +} +impl<'a> _FBM20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM21W<'a> { + w: &'a mut W, +} +impl<'a> _FBM21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM22W<'a> { + w: &'a mut W, +} +impl<'a> _FBM22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM23W<'a> { + w: &'a mut W, +} +impl<'a> _FBM23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM24W<'a> { + w: &'a mut W, +} +impl<'a> _FBM24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM25W<'a> { + w: &'a mut W, +} +impl<'a> _FBM25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM26W<'a> { + w: &'a mut W, +} +impl<'a> _FBM26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBM27W<'a> { + w: &'a mut W, +} +impl<'a> _FBM27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter mode"] + #[inline] + pub fn fbm0(&self) -> FBM0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM0R { bits } + } + #[doc = "Bit 1 - Filter mode"] + #[inline] + pub fn fbm1(&self) -> FBM1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM1R { bits } + } + #[doc = "Bit 2 - Filter mode"] + #[inline] + pub fn fbm2(&self) -> FBM2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM2R { bits } + } + #[doc = "Bit 3 - Filter mode"] + #[inline] + pub fn fbm3(&self) -> FBM3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM3R { bits } + } + #[doc = "Bit 4 - Filter mode"] + #[inline] + pub fn fbm4(&self) -> FBM4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM4R { bits } + } + #[doc = "Bit 5 - Filter mode"] + #[inline] + pub fn fbm5(&self) -> FBM5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM5R { bits } + } + #[doc = "Bit 6 - Filter mode"] + #[inline] + pub fn fbm6(&self) -> FBM6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM6R { bits } + } + #[doc = "Bit 7 - Filter mode"] + #[inline] + pub fn fbm7(&self) -> FBM7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM7R { bits } + } + #[doc = "Bit 8 - Filter mode"] + #[inline] + pub fn fbm8(&self) -> FBM8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM8R { bits } + } + #[doc = "Bit 9 - Filter mode"] + #[inline] + pub fn fbm9(&self) -> FBM9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM9R { bits } + } + #[doc = "Bit 10 - Filter mode"] + #[inline] + pub fn fbm10(&self) -> FBM10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM10R { bits } + } + #[doc = "Bit 11 - Filter mode"] + #[inline] + pub fn fbm11(&self) -> FBM11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM11R { bits } + } + #[doc = "Bit 12 - Filter mode"] + #[inline] + pub fn fbm12(&self) -> FBM12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM12R { bits } + } + #[doc = "Bit 13 - Filter mode"] + #[inline] + pub fn fbm13(&self) -> FBM13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM13R { bits } + } + #[doc = "Bit 14 - Filter mode"] + #[inline] + pub fn fbm14(&self) -> FBM14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM14R { bits } + } + #[doc = "Bit 15 - Filter mode"] + #[inline] + pub fn fbm15(&self) -> FBM15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM15R { bits } + } + #[doc = "Bit 16 - Filter mode"] + #[inline] + pub fn fbm16(&self) -> FBM16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM16R { bits } + } + #[doc = "Bit 17 - Filter mode"] + #[inline] + pub fn fbm17(&self) -> FBM17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM17R { bits } + } + #[doc = "Bit 18 - Filter mode"] + #[inline] + pub fn fbm18(&self) -> FBM18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM18R { bits } + } + #[doc = "Bit 19 - Filter mode"] + #[inline] + pub fn fbm19(&self) -> FBM19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM19R { bits } + } + #[doc = "Bit 20 - Filter mode"] + #[inline] + pub fn fbm20(&self) -> FBM20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM20R { bits } + } + #[doc = "Bit 21 - Filter mode"] + #[inline] + pub fn fbm21(&self) -> FBM21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM21R { bits } + } + #[doc = "Bit 22 - Filter mode"] + #[inline] + pub fn fbm22(&self) -> FBM22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM22R { bits } + } + #[doc = "Bit 23 - Filter mode"] + #[inline] + pub fn fbm23(&self) -> FBM23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM23R { bits } + } + #[doc = "Bit 24 - Filter mode"] + #[inline] + pub fn fbm24(&self) -> FBM24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM24R { bits } + } + #[doc = "Bit 25 - Filter mode"] + #[inline] + pub fn fbm25(&self) -> FBM25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM25R { bits } + } + #[doc = "Bit 26 - Filter mode"] + #[inline] + pub fn fbm26(&self) -> FBM26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM26R { bits } + } + #[doc = "Bit 27 - Filter mode"] + #[inline] + pub fn fbm27(&self) -> FBM27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FBM27R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter mode"] + #[inline] + pub fn fbm0(&mut self) -> _FBM0W { + _FBM0W { w: self } + } + #[doc = "Bit 1 - Filter mode"] + #[inline] + pub fn fbm1(&mut self) -> _FBM1W { + _FBM1W { w: self } + } + #[doc = "Bit 2 - Filter mode"] + #[inline] + pub fn fbm2(&mut self) -> _FBM2W { + _FBM2W { w: self } + } + #[doc = "Bit 3 - Filter mode"] + #[inline] + pub fn fbm3(&mut self) -> _FBM3W { + _FBM3W { w: self } + } + #[doc = "Bit 4 - Filter mode"] + #[inline] + pub fn fbm4(&mut self) -> _FBM4W { + _FBM4W { w: self } + } + #[doc = "Bit 5 - Filter mode"] + #[inline] + pub fn fbm5(&mut self) -> _FBM5W { + _FBM5W { w: self } + } + #[doc = "Bit 6 - Filter mode"] + #[inline] + pub fn fbm6(&mut self) -> _FBM6W { + _FBM6W { w: self } + } + #[doc = "Bit 7 - Filter mode"] + #[inline] + pub fn fbm7(&mut self) -> _FBM7W { + _FBM7W { w: self } + } + #[doc = "Bit 8 - Filter mode"] + #[inline] + pub fn fbm8(&mut self) -> _FBM8W { + _FBM8W { w: self } + } + #[doc = "Bit 9 - Filter mode"] + #[inline] + pub fn fbm9(&mut self) -> _FBM9W { + _FBM9W { w: self } + } + #[doc = "Bit 10 - Filter mode"] + #[inline] + pub fn fbm10(&mut self) -> _FBM10W { + _FBM10W { w: self } + } + #[doc = "Bit 11 - Filter mode"] + #[inline] + pub fn fbm11(&mut self) -> _FBM11W { + _FBM11W { w: self } + } + #[doc = "Bit 12 - Filter mode"] + #[inline] + pub fn fbm12(&mut self) -> _FBM12W { + _FBM12W { w: self } + } + #[doc = "Bit 13 - Filter mode"] + #[inline] + pub fn fbm13(&mut self) -> _FBM13W { + _FBM13W { w: self } + } + #[doc = "Bit 14 - Filter mode"] + #[inline] + pub fn fbm14(&mut self) -> _FBM14W { + _FBM14W { w: self } + } + #[doc = "Bit 15 - Filter mode"] + #[inline] + pub fn fbm15(&mut self) -> _FBM15W { + _FBM15W { w: self } + } + #[doc = "Bit 16 - Filter mode"] + #[inline] + pub fn fbm16(&mut self) -> _FBM16W { + _FBM16W { w: self } + } + #[doc = "Bit 17 - Filter mode"] + #[inline] + pub fn fbm17(&mut self) -> _FBM17W { + _FBM17W { w: self } + } + #[doc = "Bit 18 - Filter mode"] + #[inline] + pub fn fbm18(&mut self) -> _FBM18W { + _FBM18W { w: self } + } + #[doc = "Bit 19 - Filter mode"] + #[inline] + pub fn fbm19(&mut self) -> _FBM19W { + _FBM19W { w: self } + } + #[doc = "Bit 20 - Filter mode"] + #[inline] + pub fn fbm20(&mut self) -> _FBM20W { + _FBM20W { w: self } + } + #[doc = "Bit 21 - Filter mode"] + #[inline] + pub fn fbm21(&mut self) -> _FBM21W { + _FBM21W { w: self } + } + #[doc = "Bit 22 - Filter mode"] + #[inline] + pub fn fbm22(&mut self) -> _FBM22W { + _FBM22W { w: self } + } + #[doc = "Bit 23 - Filter mode"] + #[inline] + pub fn fbm23(&mut self) -> _FBM23W { + _FBM23W { w: self } + } + #[doc = "Bit 24 - Filter mode"] + #[inline] + pub fn fbm24(&mut self) -> _FBM24W { + _FBM24W { w: self } + } + #[doc = "Bit 25 - Filter mode"] + #[inline] + pub fn fbm25(&mut self) -> _FBM25W { + _FBM25W { w: self } + } + #[doc = "Bit 26 - Filter mode"] + #[inline] + pub fn fbm26(&mut self) -> _FBM26W { + _FBM26W { w: self } + } + #[doc = "Bit 27 - Filter mode"] + #[inline] + pub fn fbm27(&mut self) -> _FBM27W { + _FBM27W { w: self } + } +} diff --git a/src/can1/fmr/mod.rs b/src/can1/fmr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..537bda3fcf9ddf69773b92240ea24b89417e276a --- /dev/null +++ b/src/can1/fmr/mod.rs @@ -0,0 +1,164 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FMR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CAN2SBR { + bits: u8, +} +impl CAN2SBR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FINITR { + bits: bool, +} +impl FINITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CAN2SBW<'a> { + w: &'a mut W, +} +impl<'a> _CAN2SBW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FINITW<'a> { + w: &'a mut W, +} +impl<'a> _FINITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:13 - CAN2SB"] + #[inline] + pub fn can2sb(&self) -> CAN2SBR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CAN2SBR { bits } + } + #[doc = "Bit 0 - FINIT"] + #[inline] + pub fn finit(&self) -> FINITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FINITR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 706481665 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:13 - CAN2SB"] + #[inline] + pub fn can2sb(&mut self) -> _CAN2SBW { + _CAN2SBW { w: self } + } + #[doc = "Bit 0 - FINIT"] + #[inline] + pub fn finit(&mut self) -> _FINITW { + _FINITW { w: self } + } +} diff --git a/src/can1/fs1r/mod.rs b/src/can1/fs1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..28e15712199522f6fecd4e4f05569d86ddc4cdf5 --- /dev/null +++ b/src/can1/fs1r/mod.rs @@ -0,0 +1,1716 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSC0R { + bits: bool, +} +impl FSC0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC1R { + bits: bool, +} +impl FSC1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC2R { + bits: bool, +} +impl FSC2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC3R { + bits: bool, +} +impl FSC3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC4R { + bits: bool, +} +impl FSC4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC5R { + bits: bool, +} +impl FSC5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC6R { + bits: bool, +} +impl FSC6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC7R { + bits: bool, +} +impl FSC7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC8R { + bits: bool, +} +impl FSC8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC9R { + bits: bool, +} +impl FSC9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC10R { + bits: bool, +} +impl FSC10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC11R { + bits: bool, +} +impl FSC11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC12R { + bits: bool, +} +impl FSC12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC13R { + bits: bool, +} +impl FSC13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC14R { + bits: bool, +} +impl FSC14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC15R { + bits: bool, +} +impl FSC15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC16R { + bits: bool, +} +impl FSC16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC17R { + bits: bool, +} +impl FSC17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC18R { + bits: bool, +} +impl FSC18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC19R { + bits: bool, +} +impl FSC19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC20R { + bits: bool, +} +impl FSC20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC21R { + bits: bool, +} +impl FSC21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC22R { + bits: bool, +} +impl FSC22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC23R { + bits: bool, +} +impl FSC23R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC24R { + bits: bool, +} +impl FSC24R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC25R { + bits: bool, +} +impl FSC25R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC26R { + bits: bool, +} +impl FSC26R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSC27R { + bits: bool, +} +impl FSC27R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSC0W<'a> { + w: &'a mut W, +} +impl<'a> _FSC0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC1W<'a> { + w: &'a mut W, +} +impl<'a> _FSC1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC2W<'a> { + w: &'a mut W, +} +impl<'a> _FSC2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC3W<'a> { + w: &'a mut W, +} +impl<'a> _FSC3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC4W<'a> { + w: &'a mut W, +} +impl<'a> _FSC4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC5W<'a> { + w: &'a mut W, +} +impl<'a> _FSC5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC6W<'a> { + w: &'a mut W, +} +impl<'a> _FSC6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC7W<'a> { + w: &'a mut W, +} +impl<'a> _FSC7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC8W<'a> { + w: &'a mut W, +} +impl<'a> _FSC8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC9W<'a> { + w: &'a mut W, +} +impl<'a> _FSC9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC10W<'a> { + w: &'a mut W, +} +impl<'a> _FSC10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC11W<'a> { + w: &'a mut W, +} +impl<'a> _FSC11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC12W<'a> { + w: &'a mut W, +} +impl<'a> _FSC12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC13W<'a> { + w: &'a mut W, +} +impl<'a> _FSC13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC14W<'a> { + w: &'a mut W, +} +impl<'a> _FSC14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC15W<'a> { + w: &'a mut W, +} +impl<'a> _FSC15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC16W<'a> { + w: &'a mut W, +} +impl<'a> _FSC16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC17W<'a> { + w: &'a mut W, +} +impl<'a> _FSC17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC18W<'a> { + w: &'a mut W, +} +impl<'a> _FSC18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC19W<'a> { + w: &'a mut W, +} +impl<'a> _FSC19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC20W<'a> { + w: &'a mut W, +} +impl<'a> _FSC20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC21W<'a> { + w: &'a mut W, +} +impl<'a> _FSC21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC22W<'a> { + w: &'a mut W, +} +impl<'a> _FSC22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC23W<'a> { + w: &'a mut W, +} +impl<'a> _FSC23W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC24W<'a> { + w: &'a mut W, +} +impl<'a> _FSC24W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC25W<'a> { + w: &'a mut W, +} +impl<'a> _FSC25W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC26W<'a> { + w: &'a mut W, +} +impl<'a> _FSC26W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSC27W<'a> { + w: &'a mut W, +} +impl<'a> _FSC27W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Filter scale configuration"] + #[inline] + pub fn fsc0(&self) -> FSC0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC0R { bits } + } + #[doc = "Bit 1 - Filter scale configuration"] + #[inline] + pub fn fsc1(&self) -> FSC1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC1R { bits } + } + #[doc = "Bit 2 - Filter scale configuration"] + #[inline] + pub fn fsc2(&self) -> FSC2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC2R { bits } + } + #[doc = "Bit 3 - Filter scale configuration"] + #[inline] + pub fn fsc3(&self) -> FSC3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC3R { bits } + } + #[doc = "Bit 4 - Filter scale configuration"] + #[inline] + pub fn fsc4(&self) -> FSC4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC4R { bits } + } + #[doc = "Bit 5 - Filter scale configuration"] + #[inline] + pub fn fsc5(&self) -> FSC5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC5R { bits } + } + #[doc = "Bit 6 - Filter scale configuration"] + #[inline] + pub fn fsc6(&self) -> FSC6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC6R { bits } + } + #[doc = "Bit 7 - Filter scale configuration"] + #[inline] + pub fn fsc7(&self) -> FSC7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC7R { bits } + } + #[doc = "Bit 8 - Filter scale configuration"] + #[inline] + pub fn fsc8(&self) -> FSC8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC8R { bits } + } + #[doc = "Bit 9 - Filter scale configuration"] + #[inline] + pub fn fsc9(&self) -> FSC9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC9R { bits } + } + #[doc = "Bit 10 - Filter scale configuration"] + #[inline] + pub fn fsc10(&self) -> FSC10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC10R { bits } + } + #[doc = "Bit 11 - Filter scale configuration"] + #[inline] + pub fn fsc11(&self) -> FSC11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC11R { bits } + } + #[doc = "Bit 12 - Filter scale configuration"] + #[inline] + pub fn fsc12(&self) -> FSC12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC12R { bits } + } + #[doc = "Bit 13 - Filter scale configuration"] + #[inline] + pub fn fsc13(&self) -> FSC13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC13R { bits } + } + #[doc = "Bit 14 - Filter scale configuration"] + #[inline] + pub fn fsc14(&self) -> FSC14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC14R { bits } + } + #[doc = "Bit 15 - Filter scale configuration"] + #[inline] + pub fn fsc15(&self) -> FSC15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC15R { bits } + } + #[doc = "Bit 16 - Filter scale configuration"] + #[inline] + pub fn fsc16(&self) -> FSC16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC16R { bits } + } + #[doc = "Bit 17 - Filter scale configuration"] + #[inline] + pub fn fsc17(&self) -> FSC17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC17R { bits } + } + #[doc = "Bit 18 - Filter scale configuration"] + #[inline] + pub fn fsc18(&self) -> FSC18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC18R { bits } + } + #[doc = "Bit 19 - Filter scale configuration"] + #[inline] + pub fn fsc19(&self) -> FSC19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC19R { bits } + } + #[doc = "Bit 20 - Filter scale configuration"] + #[inline] + pub fn fsc20(&self) -> FSC20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC20R { bits } + } + #[doc = "Bit 21 - Filter scale configuration"] + #[inline] + pub fn fsc21(&self) -> FSC21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC21R { bits } + } + #[doc = "Bit 22 - Filter scale configuration"] + #[inline] + pub fn fsc22(&self) -> FSC22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC22R { bits } + } + #[doc = "Bit 23 - Filter scale configuration"] + #[inline] + pub fn fsc23(&self) -> FSC23R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC23R { bits } + } + #[doc = "Bit 24 - Filter scale configuration"] + #[inline] + pub fn fsc24(&self) -> FSC24R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC24R { bits } + } + #[doc = "Bit 25 - Filter scale configuration"] + #[inline] + pub fn fsc25(&self) -> FSC25R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC25R { bits } + } + #[doc = "Bit 26 - Filter scale configuration"] + #[inline] + pub fn fsc26(&self) -> FSC26R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC26R { bits } + } + #[doc = "Bit 27 - Filter scale configuration"] + #[inline] + pub fn fsc27(&self) -> FSC27R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSC27R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Filter scale configuration"] + #[inline] + pub fn fsc0(&mut self) -> _FSC0W { + _FSC0W { w: self } + } + #[doc = "Bit 1 - Filter scale configuration"] + #[inline] + pub fn fsc1(&mut self) -> _FSC1W { + _FSC1W { w: self } + } + #[doc = "Bit 2 - Filter scale configuration"] + #[inline] + pub fn fsc2(&mut self) -> _FSC2W { + _FSC2W { w: self } + } + #[doc = "Bit 3 - Filter scale configuration"] + #[inline] + pub fn fsc3(&mut self) -> _FSC3W { + _FSC3W { w: self } + } + #[doc = "Bit 4 - Filter scale configuration"] + #[inline] + pub fn fsc4(&mut self) -> _FSC4W { + _FSC4W { w: self } + } + #[doc = "Bit 5 - Filter scale configuration"] + #[inline] + pub fn fsc5(&mut self) -> _FSC5W { + _FSC5W { w: self } + } + #[doc = "Bit 6 - Filter scale configuration"] + #[inline] + pub fn fsc6(&mut self) -> _FSC6W { + _FSC6W { w: self } + } + #[doc = "Bit 7 - Filter scale configuration"] + #[inline] + pub fn fsc7(&mut self) -> _FSC7W { + _FSC7W { w: self } + } + #[doc = "Bit 8 - Filter scale configuration"] + #[inline] + pub fn fsc8(&mut self) -> _FSC8W { + _FSC8W { w: self } + } + #[doc = "Bit 9 - Filter scale configuration"] + #[inline] + pub fn fsc9(&mut self) -> _FSC9W { + _FSC9W { w: self } + } + #[doc = "Bit 10 - Filter scale configuration"] + #[inline] + pub fn fsc10(&mut self) -> _FSC10W { + _FSC10W { w: self } + } + #[doc = "Bit 11 - Filter scale configuration"] + #[inline] + pub fn fsc11(&mut self) -> _FSC11W { + _FSC11W { w: self } + } + #[doc = "Bit 12 - Filter scale configuration"] + #[inline] + pub fn fsc12(&mut self) -> _FSC12W { + _FSC12W { w: self } + } + #[doc = "Bit 13 - Filter scale configuration"] + #[inline] + pub fn fsc13(&mut self) -> _FSC13W { + _FSC13W { w: self } + } + #[doc = "Bit 14 - Filter scale configuration"] + #[inline] + pub fn fsc14(&mut self) -> _FSC14W { + _FSC14W { w: self } + } + #[doc = "Bit 15 - Filter scale configuration"] + #[inline] + pub fn fsc15(&mut self) -> _FSC15W { + _FSC15W { w: self } + } + #[doc = "Bit 16 - Filter scale configuration"] + #[inline] + pub fn fsc16(&mut self) -> _FSC16W { + _FSC16W { w: self } + } + #[doc = "Bit 17 - Filter scale configuration"] + #[inline] + pub fn fsc17(&mut self) -> _FSC17W { + _FSC17W { w: self } + } + #[doc = "Bit 18 - Filter scale configuration"] + #[inline] + pub fn fsc18(&mut self) -> _FSC18W { + _FSC18W { w: self } + } + #[doc = "Bit 19 - Filter scale configuration"] + #[inline] + pub fn fsc19(&mut self) -> _FSC19W { + _FSC19W { w: self } + } + #[doc = "Bit 20 - Filter scale configuration"] + #[inline] + pub fn fsc20(&mut self) -> _FSC20W { + _FSC20W { w: self } + } + #[doc = "Bit 21 - Filter scale configuration"] + #[inline] + pub fn fsc21(&mut self) -> _FSC21W { + _FSC21W { w: self } + } + #[doc = "Bit 22 - Filter scale configuration"] + #[inline] + pub fn fsc22(&mut self) -> _FSC22W { + _FSC22W { w: self } + } + #[doc = "Bit 23 - Filter scale configuration"] + #[inline] + pub fn fsc23(&mut self) -> _FSC23W { + _FSC23W { w: self } + } + #[doc = "Bit 24 - Filter scale configuration"] + #[inline] + pub fn fsc24(&mut self) -> _FSC24W { + _FSC24W { w: self } + } + #[doc = "Bit 25 - Filter scale configuration"] + #[inline] + pub fn fsc25(&mut self) -> _FSC25W { + _FSC25W { w: self } + } + #[doc = "Bit 26 - Filter scale configuration"] + #[inline] + pub fn fsc26(&mut self) -> _FSC26W { + _FSC26W { w: self } + } + #[doc = "Bit 27 - Filter scale configuration"] + #[inline] + pub fn fsc27(&mut self) -> _FSC27W { + _FSC27W { w: self } + } +} diff --git a/src/can1/ier/mod.rs b/src/can1/ier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8bdab96e56b79e6d07771b187aaee8136c14d2b4 --- /dev/null +++ b/src/can1/ier/mod.rs @@ -0,0 +1,890 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SLKIER { + bits: bool, +} +impl SLKIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WKUIER { + bits: bool, +} +impl WKUIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIER { + bits: bool, +} +impl ERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LECIER { + bits: bool, +} +impl LECIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BOFIER { + bits: bool, +} +impl BOFIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPVIER { + bits: bool, +} +impl EPVIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EWGIER { + bits: bool, +} +impl EWGIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FOVIE1R { + bits: bool, +} +impl FOVIE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFIE1R { + bits: bool, +} +impl FFIE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMPIE1R { + bits: bool, +} +impl FMPIE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FOVIE0R { + bits: bool, +} +impl FOVIE0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFIE0R { + bits: bool, +} +impl FFIE0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMPIE0R { + bits: bool, +} +impl FMPIE0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TMEIER { + bits: bool, +} +impl TMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SLKIEW<'a> { + w: &'a mut W, +} +impl<'a> _SLKIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WKUIEW<'a> { + w: &'a mut W, +} +impl<'a> _WKUIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LECIEW<'a> { + w: &'a mut W, +} +impl<'a> _LECIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BOFIEW<'a> { + w: &'a mut W, +} +impl<'a> _BOFIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPVIEW<'a> { + w: &'a mut W, +} +impl<'a> _EPVIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EWGIEW<'a> { + w: &'a mut W, +} +impl<'a> _EWGIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOVIE1W<'a> { + w: &'a mut W, +} +impl<'a> _FOVIE1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFIE1W<'a> { + w: &'a mut W, +} +impl<'a> _FFIE1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FMPIE1W<'a> { + w: &'a mut W, +} +impl<'a> _FMPIE1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOVIE0W<'a> { + w: &'a mut W, +} +impl<'a> _FOVIE0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFIE0W<'a> { + w: &'a mut W, +} +impl<'a> _FFIE0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FMPIE0W<'a> { + w: &'a mut W, +} +impl<'a> _FMPIE0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 17 - SLKIE"] + #[inline] + pub fn slkie(&self) -> SLKIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SLKIER { bits } + } + #[doc = "Bit 16 - WKUIE"] + #[inline] + pub fn wkuie(&self) -> WKUIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WKUIER { bits } + } + #[doc = "Bit 15 - ERRIE"] + #[inline] + pub fn errie(&self) -> ERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIER { bits } + } + #[doc = "Bit 11 - LECIE"] + #[inline] + pub fn lecie(&self) -> LECIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LECIER { bits } + } + #[doc = "Bit 10 - BOFIE"] + #[inline] + pub fn bofie(&self) -> BOFIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BOFIER { bits } + } + #[doc = "Bit 9 - EPVIE"] + #[inline] + pub fn epvie(&self) -> EPVIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPVIER { bits } + } + #[doc = "Bit 8 - EWGIE"] + #[inline] + pub fn ewgie(&self) -> EWGIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EWGIER { bits } + } + #[doc = "Bit 6 - FOVIE1"] + #[inline] + pub fn fovie1(&self) -> FOVIE1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FOVIE1R { bits } + } + #[doc = "Bit 5 - FFIE1"] + #[inline] + pub fn ffie1(&self) -> FFIE1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFIE1R { bits } + } + #[doc = "Bit 4 - FMPIE1"] + #[inline] + pub fn fmpie1(&self) -> FMPIE1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FMPIE1R { bits } + } + #[doc = "Bit 3 - FOVIE0"] + #[inline] + pub fn fovie0(&self) -> FOVIE0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FOVIE0R { bits } + } + #[doc = "Bit 2 - FFIE0"] + #[inline] + pub fn ffie0(&self) -> FFIE0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFIE0R { bits } + } + #[doc = "Bit 1 - FMPIE0"] + #[inline] + pub fn fmpie0(&self) -> FMPIE0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FMPIE0R { bits } + } + #[doc = "Bit 0 - TMEIE"] + #[inline] + pub fn tmeie(&self) -> TMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TMEIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 17 - SLKIE"] + #[inline] + pub fn slkie(&mut self) -> _SLKIEW { + _SLKIEW { w: self } + } + #[doc = "Bit 16 - WKUIE"] + #[inline] + pub fn wkuie(&mut self) -> _WKUIEW { + _WKUIEW { w: self } + } + #[doc = "Bit 15 - ERRIE"] + #[inline] + pub fn errie(&mut self) -> _ERRIEW { + _ERRIEW { w: self } + } + #[doc = "Bit 11 - LECIE"] + #[inline] + pub fn lecie(&mut self) -> _LECIEW { + _LECIEW { w: self } + } + #[doc = "Bit 10 - BOFIE"] + #[inline] + pub fn bofie(&mut self) -> _BOFIEW { + _BOFIEW { w: self } + } + #[doc = "Bit 9 - EPVIE"] + #[inline] + pub fn epvie(&mut self) -> _EPVIEW { + _EPVIEW { w: self } + } + #[doc = "Bit 8 - EWGIE"] + #[inline] + pub fn ewgie(&mut self) -> _EWGIEW { + _EWGIEW { w: self } + } + #[doc = "Bit 6 - FOVIE1"] + #[inline] + pub fn fovie1(&mut self) -> _FOVIE1W { + _FOVIE1W { w: self } + } + #[doc = "Bit 5 - FFIE1"] + #[inline] + pub fn ffie1(&mut self) -> _FFIE1W { + _FFIE1W { w: self } + } + #[doc = "Bit 4 - FMPIE1"] + #[inline] + pub fn fmpie1(&mut self) -> _FMPIE1W { + _FMPIE1W { w: self } + } + #[doc = "Bit 3 - FOVIE0"] + #[inline] + pub fn fovie0(&mut self) -> _FOVIE0W { + _FOVIE0W { w: self } + } + #[doc = "Bit 2 - FFIE0"] + #[inline] + pub fn ffie0(&mut self) -> _FFIE0W { + _FFIE0W { w: self } + } + #[doc = "Bit 1 - FMPIE0"] + #[inline] + pub fn fmpie0(&mut self) -> _FMPIE0W { + _FMPIE0W { w: self } + } + #[doc = "Bit 0 - TMEIE"] + #[inline] + pub fn tmeie(&mut self) -> _TMEIEW { + _TMEIEW { w: self } + } +} diff --git a/src/can1/mcr/mod.rs b/src/can1/mcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2ca3e67af5d7ac61cfd9ba2e4b6c3ee0d5b65eeb --- /dev/null +++ b/src/can1/mcr/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBFR { + bits: bool, +} +impl DBFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RESETR { + bits: bool, +} +impl RESETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TTCMR { + bits: bool, +} +impl TTCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ABOMR { + bits: bool, +} +impl ABOMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWUMR { + bits: bool, +} +impl AWUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NARTR { + bits: bool, +} +impl NARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RFLMR { + bits: bool, +} +impl RFLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFPR { + bits: bool, +} +impl TXFPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SLEEPR { + bits: bool, +} +impl SLEEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INRQR { + bits: bool, +} +impl INRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DBFW<'a> { + w: &'a mut W, +} +impl<'a> _DBFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RESETW<'a> { + w: &'a mut W, +} +impl<'a> _RESETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TTCMW<'a> { + w: &'a mut W, +} +impl<'a> _TTCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABOMW<'a> { + w: &'a mut W, +} +impl<'a> _ABOMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWUMW<'a> { + w: &'a mut W, +} +impl<'a> _AWUMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NARTW<'a> { + w: &'a mut W, +} +impl<'a> _NARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RFLMW<'a> { + w: &'a mut W, +} +impl<'a> _RFLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFPW<'a> { + w: &'a mut W, +} +impl<'a> _TXFPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SLEEPW<'a> { + w: &'a mut W, +} +impl<'a> _SLEEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INRQW<'a> { + w: &'a mut W, +} +impl<'a> _INRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - DBF"] + #[inline] + pub fn dbf(&self) -> DBFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBFR { bits } + } + #[doc = "Bit 15 - RESET"] + #[inline] + pub fn reset(&self) -> RESETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RESETR { bits } + } + #[doc = "Bit 7 - TTCM"] + #[inline] + pub fn ttcm(&self) -> TTCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TTCMR { bits } + } + #[doc = "Bit 6 - ABOM"] + #[inline] + pub fn abom(&self) -> ABOMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ABOMR { bits } + } + #[doc = "Bit 5 - AWUM"] + #[inline] + pub fn awum(&self) -> AWUMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWUMR { bits } + } + #[doc = "Bit 4 - NART"] + #[inline] + pub fn nart(&self) -> NARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NARTR { bits } + } + #[doc = "Bit 3 - RFLM"] + #[inline] + pub fn rflm(&self) -> RFLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RFLMR { bits } + } + #[doc = "Bit 2 - TXFP"] + #[inline] + pub fn txfp(&self) -> TXFPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFPR { bits } + } + #[doc = "Bit 1 - SLEEP"] + #[inline] + pub fn sleep(&self) -> SLEEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SLEEPR { bits } + } + #[doc = "Bit 0 - INRQ"] + #[inline] + pub fn inrq(&self) -> INRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INRQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 65538 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - DBF"] + #[inline] + pub fn dbf(&mut self) -> _DBFW { + _DBFW { w: self } + } + #[doc = "Bit 15 - RESET"] + #[inline] + pub fn reset(&mut self) -> _RESETW { + _RESETW { w: self } + } + #[doc = "Bit 7 - TTCM"] + #[inline] + pub fn ttcm(&mut self) -> _TTCMW { + _TTCMW { w: self } + } + #[doc = "Bit 6 - ABOM"] + #[inline] + pub fn abom(&mut self) -> _ABOMW { + _ABOMW { w: self } + } + #[doc = "Bit 5 - AWUM"] + #[inline] + pub fn awum(&mut self) -> _AWUMW { + _AWUMW { w: self } + } + #[doc = "Bit 4 - NART"] + #[inline] + pub fn nart(&mut self) -> _NARTW { + _NARTW { w: self } + } + #[doc = "Bit 3 - RFLM"] + #[inline] + pub fn rflm(&mut self) -> _RFLMW { + _RFLMW { w: self } + } + #[doc = "Bit 2 - TXFP"] + #[inline] + pub fn txfp(&mut self) -> _TXFPW { + _TXFPW { w: self } + } + #[doc = "Bit 1 - SLEEP"] + #[inline] + pub fn sleep(&mut self) -> _SLEEPW { + _SLEEPW { w: self } + } + #[doc = "Bit 0 - INRQ"] + #[inline] + pub fn inrq(&mut self) -> _INRQW { + _INRQW { w: self } + } +} diff --git a/src/can1/mod.rs b/src/can1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..92d0dc00929f53957020f07f0851982103f143ee --- /dev/null +++ b/src/can1/mod.rs @@ -0,0 +1,722 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - master control register"] + pub mcr: MCR, + #[doc = "0x04 - master status register"] + pub msr: MSR, + #[doc = "0x08 - transmit status register"] + pub tsr: TSR, + #[doc = "0x0c - receive FIFO 0 register"] + pub rf0r: RF0R, + #[doc = "0x10 - receive FIFO 1 register"] + pub rf1r: RF1R, + #[doc = "0x14 - interrupt enable register"] + pub ier: IER, + #[doc = "0x18 - interrupt enable register"] + pub esr: ESR, + #[doc = "0x1c - bit timing register"] + pub btr: BTR, + _reserved0: [u8; 352usize], + #[doc = "0x180 - TX mailbox identifier register"] + pub ti0r: TI0R, + #[doc = "0x184 - mailbox data length control and time stamp register"] + pub tdt0r: TDT0R, + #[doc = "0x188 - mailbox data low register"] + pub tdl0r: TDL0R, + #[doc = "0x18c - mailbox data high register"] + pub tdh0r: TDH0R, + #[doc = "0x190 - mailbox identifier register"] + pub ti1r: TI1R, + #[doc = "0x194 - mailbox data length control and time stamp register"] + pub tdt1r: TDT1R, + #[doc = "0x198 - mailbox data low register"] + pub tdl1r: TDL1R, + #[doc = "0x19c - mailbox data high register"] + pub tdh1r: TDH1R, + #[doc = "0x1a0 - mailbox identifier register"] + pub ti2r: TI2R, + #[doc = "0x1a4 - mailbox data length control and time stamp register"] + pub tdt2r: TDT2R, + #[doc = "0x1a8 - mailbox data low register"] + pub tdl2r: TDL2R, + #[doc = "0x1ac - mailbox data high register"] + pub tdh2r: TDH2R, + #[doc = "0x1b0 - receive FIFO mailbox identifier register"] + pub ri0r: RI0R, + #[doc = "0x1b4 - mailbox data high register"] + pub rdt0r: RDT0R, + #[doc = "0x1b8 - mailbox data high register"] + pub rdl0r: RDL0R, + #[doc = "0x1bc - receive FIFO mailbox data high register"] + pub rdh0r: RDH0R, + #[doc = "0x1c0 - mailbox data high register"] + pub ri1r: RI1R, + #[doc = "0x1c4 - mailbox data high register"] + pub rdt1r: RDT1R, + #[doc = "0x1c8 - mailbox data high register"] + pub rdl1r: RDL1R, + #[doc = "0x1cc - mailbox data high register"] + pub rdh1r: RDH1R, + _reserved1: [u8; 48usize], + #[doc = "0x200 - filter master register"] + pub fmr: FMR, + #[doc = "0x204 - filter mode register"] + pub fm1r: FM1R, + _reserved2: [u8; 4usize], + #[doc = "0x20c - filter scale register"] + pub fs1r: FS1R, + _reserved3: [u8; 4usize], + #[doc = "0x214 - filter FIFO assignment register"] + pub ffa1r: FFA1R, + _reserved4: [u8; 4usize], + #[doc = "0x21c - filter activation register"] + pub fa1r: FA1R, + _reserved5: [u8; 32usize], + #[doc = "0x240 - Filter bank 0 register 1"] + pub f0r1: F0R1, + #[doc = "0x244 - Filter bank 0 register 2"] + pub f0r2: F0R2, + #[doc = "0x248 - Filter bank 1 register 1"] + pub f1r1: F1R1, + #[doc = "0x24c - Filter bank 1 register 2"] + pub f1r2: F1R2, + #[doc = "0x250 - Filter bank 2 register 1"] + pub f2r1: F2R1, + #[doc = "0x254 - Filter bank 2 register 2"] + pub f2r2: F2R2, + #[doc = "0x258 - Filter bank 3 register 1"] + pub f3r1: F3R1, + #[doc = "0x25c - Filter bank 3 register 2"] + pub f3r2: F3R2, + #[doc = "0x260 - Filter bank 4 register 1"] + pub f4r1: F4R1, + #[doc = "0x264 - Filter bank 4 register 2"] + pub f4r2: F4R2, + #[doc = "0x268 - Filter bank 5 register 1"] + pub f5r1: F5R1, + #[doc = "0x26c - Filter bank 5 register 2"] + pub f5r2: F5R2, + #[doc = "0x270 - Filter bank 6 register 1"] + pub f6r1: F6R1, + #[doc = "0x274 - Filter bank 6 register 2"] + pub f6r2: F6R2, + #[doc = "0x278 - Filter bank 7 register 1"] + pub f7r1: F7R1, + #[doc = "0x27c - Filter bank 7 register 2"] + pub f7r2: F7R2, + #[doc = "0x280 - Filter bank 8 register 1"] + pub f8r1: F8R1, + #[doc = "0x284 - Filter bank 8 register 2"] + pub f8r2: F8R2, + #[doc = "0x288 - Filter bank 9 register 1"] + pub f9r1: F9R1, + #[doc = "0x28c - Filter bank 9 register 2"] + pub f9r2: F9R2, + #[doc = "0x290 - Filter bank 10 register 1"] + pub f10r1: F10R1, + #[doc = "0x294 - Filter bank 10 register 2"] + pub f10r2: F10R2, + #[doc = "0x298 - Filter bank 11 register 1"] + pub f11r1: F11R1, + #[doc = "0x29c - Filter bank 11 register 2"] + pub f11r2: F11R2, + #[doc = "0x2a0 - Filter bank 4 register 1"] + pub f12r1: F12R1, + #[doc = "0x2a4 - Filter bank 12 register 2"] + pub f12r2: F12R2, + #[doc = "0x2a8 - Filter bank 13 register 1"] + pub f13r1: F13R1, + #[doc = "0x2ac - Filter bank 13 register 2"] + pub f13r2: F13R2, + #[doc = "0x2b0 - Filter bank 14 register 1"] + pub f14r1: F14R1, + #[doc = "0x2b4 - Filter bank 14 register 2"] + pub f14r2: F14R2, + #[doc = "0x2b8 - Filter bank 15 register 1"] + pub f15r1: F15R1, + #[doc = "0x2bc - Filter bank 15 register 2"] + pub f15r2: F15R2, + #[doc = "0x2c0 - Filter bank 16 register 1"] + pub f16r1: F16R1, + #[doc = "0x2c4 - Filter bank 16 register 2"] + pub f16r2: F16R2, + #[doc = "0x2c8 - Filter bank 17 register 1"] + pub f17r1: F17R1, + #[doc = "0x2cc - Filter bank 17 register 2"] + pub f17r2: F17R2, + #[doc = "0x2d0 - Filter bank 18 register 1"] + pub f18r1: F18R1, + #[doc = "0x2d4 - Filter bank 18 register 2"] + pub f18r2: F18R2, + #[doc = "0x2d8 - Filter bank 19 register 1"] + pub f19r1: F19R1, + #[doc = "0x2dc - Filter bank 19 register 2"] + pub f19r2: F19R2, + #[doc = "0x2e0 - Filter bank 20 register 1"] + pub f20r1: F20R1, + #[doc = "0x2e4 - Filter bank 20 register 2"] + pub f20r2: F20R2, + #[doc = "0x2e8 - Filter bank 21 register 1"] + pub f21r1: F21R1, + #[doc = "0x2ec - Filter bank 21 register 2"] + pub f21r2: F21R2, + #[doc = "0x2f0 - Filter bank 22 register 1"] + pub f22r1: F22R1, + #[doc = "0x2f4 - Filter bank 22 register 2"] + pub f22r2: F22R2, + #[doc = "0x2f8 - Filter bank 23 register 1"] + pub f23r1: F23R1, + #[doc = "0x2fc - Filter bank 23 register 2"] + pub f23r2: F23R2, + #[doc = "0x300 - Filter bank 24 register 1"] + pub f24r1: F24R1, + #[doc = "0x304 - Filter bank 24 register 2"] + pub f24r2: F24R2, + #[doc = "0x308 - Filter bank 25 register 1"] + pub f25r1: F25R1, + #[doc = "0x30c - Filter bank 25 register 2"] + pub f25r2: F25R2, + #[doc = "0x310 - Filter bank 26 register 1"] + pub f26r1: F26R1, + #[doc = "0x314 - Filter bank 26 register 2"] + pub f26r2: F26R2, + #[doc = "0x318 - Filter bank 27 register 1"] + pub f27r1: F27R1, + #[doc = "0x31c - Filter bank 27 register 2"] + pub f27r2: F27R2, +} +#[doc = "master control register"] +pub struct MCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "master control register"] +pub mod mcr; +#[doc = "master status register"] +pub struct MSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "master status register"] +pub mod msr; +#[doc = "transmit status register"] +pub struct TSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "transmit status register"] +pub mod tsr; +#[doc = "receive FIFO 0 register"] +pub struct RF0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "receive FIFO 0 register"] +pub mod rf0r; +#[doc = "receive FIFO 1 register"] +pub struct RF1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "receive FIFO 1 register"] +pub mod rf1r; +#[doc = "interrupt enable register"] +pub struct IER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt enable register"] +pub mod ier; +#[doc = "interrupt enable register"] +pub struct ESR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt enable register"] +pub mod esr; +#[doc = "bit timing register"] +pub struct BTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "bit timing register"] +pub mod btr; +#[doc = "TX mailbox identifier register"] +pub struct TI0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "TX mailbox identifier register"] +pub mod ti0r; +#[doc = "mailbox data length control and time stamp register"] +pub struct TDT0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data length control and time stamp register"] +pub mod tdt0r; +#[doc = "mailbox data low register"] +pub struct TDL0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data low register"] +pub mod tdl0r; +#[doc = "mailbox data high register"] +pub struct TDH0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod tdh0r; +#[doc = "mailbox identifier register"] +pub struct TI1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox identifier register"] +pub mod ti1r; +#[doc = "mailbox data length control and time stamp register"] +pub struct TDT1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data length control and time stamp register"] +pub mod tdt1r; +#[doc = "mailbox data low register"] +pub struct TDL1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data low register"] +pub mod tdl1r; +#[doc = "mailbox data high register"] +pub struct TDH1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod tdh1r; +#[doc = "mailbox identifier register"] +pub struct TI2R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox identifier register"] +pub mod ti2r; +#[doc = "mailbox data length control and time stamp register"] +pub struct TDT2R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data length control and time stamp register"] +pub mod tdt2r; +#[doc = "mailbox data low register"] +pub struct TDL2R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data low register"] +pub mod tdl2r; +#[doc = "mailbox data high register"] +pub struct TDH2R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod tdh2r; +#[doc = "receive FIFO mailbox identifier register"] +pub struct RI0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "receive FIFO mailbox identifier register"] +pub mod ri0r; +#[doc = "mailbox data high register"] +pub struct RDT0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod rdt0r; +#[doc = "mailbox data high register"] +pub struct RDL0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod rdl0r; +#[doc = "receive FIFO mailbox data high register"] +pub struct RDH0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "receive FIFO mailbox data high register"] +pub mod rdh0r; +#[doc = "mailbox data high register"] +pub struct RI1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod ri1r; +#[doc = "mailbox data high register"] +pub struct RDT1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod rdt1r; +#[doc = "mailbox data high register"] +pub struct RDL1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod rdl1r; +#[doc = "mailbox data high register"] +pub struct RDH1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mailbox data high register"] +pub mod rdh1r; +#[doc = "filter master register"] +pub struct FMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter master register"] +pub mod fmr; +#[doc = "filter mode register"] +pub struct FM1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter mode register"] +pub mod fm1r; +#[doc = "filter scale register"] +pub struct FS1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter scale register"] +pub mod fs1r; +#[doc = "filter FIFO assignment register"] +pub struct FFA1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter FIFO assignment register"] +pub mod ffa1r; +#[doc = "filter activation register"] +pub struct FA1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter activation register"] +pub mod fa1r; +#[doc = "Filter bank 0 register 1"] +pub struct F0R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 0 register 1"] +pub mod f0r1; +#[doc = "Filter bank 0 register 2"] +pub struct F0R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 0 register 2"] +pub mod f0r2; +#[doc = "Filter bank 1 register 1"] +pub struct F1R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 1 register 1"] +pub mod f1r1; +#[doc = "Filter bank 1 register 2"] +pub struct F1R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 1 register 2"] +pub mod f1r2; +#[doc = "Filter bank 2 register 1"] +pub struct F2R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 2 register 1"] +pub mod f2r1; +#[doc = "Filter bank 2 register 2"] +pub struct F2R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 2 register 2"] +pub mod f2r2; +#[doc = "Filter bank 3 register 1"] +pub struct F3R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 3 register 1"] +pub mod f3r1; +#[doc = "Filter bank 3 register 2"] +pub struct F3R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 3 register 2"] +pub mod f3r2; +#[doc = "Filter bank 4 register 1"] +pub struct F4R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 4 register 1"] +pub mod f4r1; +#[doc = "Filter bank 4 register 2"] +pub struct F4R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 4 register 2"] +pub mod f4r2; +#[doc = "Filter bank 5 register 1"] +pub struct F5R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 5 register 1"] +pub mod f5r1; +#[doc = "Filter bank 5 register 2"] +pub struct F5R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 5 register 2"] +pub mod f5r2; +#[doc = "Filter bank 6 register 1"] +pub struct F6R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 6 register 1"] +pub mod f6r1; +#[doc = "Filter bank 6 register 2"] +pub struct F6R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 6 register 2"] +pub mod f6r2; +#[doc = "Filter bank 7 register 1"] +pub struct F7R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 7 register 1"] +pub mod f7r1; +#[doc = "Filter bank 7 register 2"] +pub struct F7R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 7 register 2"] +pub mod f7r2; +#[doc = "Filter bank 8 register 1"] +pub struct F8R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 8 register 1"] +pub mod f8r1; +#[doc = "Filter bank 8 register 2"] +pub struct F8R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 8 register 2"] +pub mod f8r2; +#[doc = "Filter bank 9 register 1"] +pub struct F9R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 9 register 1"] +pub mod f9r1; +#[doc = "Filter bank 9 register 2"] +pub struct F9R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 9 register 2"] +pub mod f9r2; +#[doc = "Filter bank 10 register 1"] +pub struct F10R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 10 register 1"] +pub mod f10r1; +#[doc = "Filter bank 10 register 2"] +pub struct F10R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 10 register 2"] +pub mod f10r2; +#[doc = "Filter bank 11 register 1"] +pub struct F11R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 11 register 1"] +pub mod f11r1; +#[doc = "Filter bank 11 register 2"] +pub struct F11R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 11 register 2"] +pub mod f11r2; +#[doc = "Filter bank 4 register 1"] +pub struct F12R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 4 register 1"] +pub mod f12r1; +#[doc = "Filter bank 12 register 2"] +pub struct F12R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 12 register 2"] +pub mod f12r2; +#[doc = "Filter bank 13 register 1"] +pub struct F13R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 13 register 1"] +pub mod f13r1; +#[doc = "Filter bank 13 register 2"] +pub struct F13R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 13 register 2"] +pub mod f13r2; +#[doc = "Filter bank 14 register 1"] +pub struct F14R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 14 register 1"] +pub mod f14r1; +#[doc = "Filter bank 14 register 2"] +pub struct F14R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 14 register 2"] +pub mod f14r2; +#[doc = "Filter bank 15 register 1"] +pub struct F15R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 15 register 1"] +pub mod f15r1; +#[doc = "Filter bank 15 register 2"] +pub struct F15R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 15 register 2"] +pub mod f15r2; +#[doc = "Filter bank 16 register 1"] +pub struct F16R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 16 register 1"] +pub mod f16r1; +#[doc = "Filter bank 16 register 2"] +pub struct F16R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 16 register 2"] +pub mod f16r2; +#[doc = "Filter bank 17 register 1"] +pub struct F17R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 17 register 1"] +pub mod f17r1; +#[doc = "Filter bank 17 register 2"] +pub struct F17R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 17 register 2"] +pub mod f17r2; +#[doc = "Filter bank 18 register 1"] +pub struct F18R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 18 register 1"] +pub mod f18r1; +#[doc = "Filter bank 18 register 2"] +pub struct F18R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 18 register 2"] +pub mod f18r2; +#[doc = "Filter bank 19 register 1"] +pub struct F19R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 19 register 1"] +pub mod f19r1; +#[doc = "Filter bank 19 register 2"] +pub struct F19R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 19 register 2"] +pub mod f19r2; +#[doc = "Filter bank 20 register 1"] +pub struct F20R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 20 register 1"] +pub mod f20r1; +#[doc = "Filter bank 20 register 2"] +pub struct F20R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 20 register 2"] +pub mod f20r2; +#[doc = "Filter bank 21 register 1"] +pub struct F21R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 21 register 1"] +pub mod f21r1; +#[doc = "Filter bank 21 register 2"] +pub struct F21R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 21 register 2"] +pub mod f21r2; +#[doc = "Filter bank 22 register 1"] +pub struct F22R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 22 register 1"] +pub mod f22r1; +#[doc = "Filter bank 22 register 2"] +pub struct F22R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 22 register 2"] +pub mod f22r2; +#[doc = "Filter bank 23 register 1"] +pub struct F23R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 23 register 1"] +pub mod f23r1; +#[doc = "Filter bank 23 register 2"] +pub struct F23R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 23 register 2"] +pub mod f23r2; +#[doc = "Filter bank 24 register 1"] +pub struct F24R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 24 register 1"] +pub mod f24r1; +#[doc = "Filter bank 24 register 2"] +pub struct F24R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 24 register 2"] +pub mod f24r2; +#[doc = "Filter bank 25 register 1"] +pub struct F25R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 25 register 1"] +pub mod f25r1; +#[doc = "Filter bank 25 register 2"] +pub struct F25R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 25 register 2"] +pub mod f25r2; +#[doc = "Filter bank 26 register 1"] +pub struct F26R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 26 register 1"] +pub mod f26r1; +#[doc = "Filter bank 26 register 2"] +pub struct F26R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 26 register 2"] +pub mod f26r2; +#[doc = "Filter bank 27 register 1"] +pub struct F27R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 27 register 1"] +pub mod f27r1; +#[doc = "Filter bank 27 register 2"] +pub struct F27R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Filter bank 27 register 2"] +pub mod f27r2; diff --git a/src/can1/msr/mod.rs b/src/can1/msr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1deb1ab10147848e4f2c801cae946823f19a7859 --- /dev/null +++ b/src/can1/msr/mod.rs @@ -0,0 +1,427 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RXR { + bits: bool, +} +impl RXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAMPR { + bits: bool, +} +impl SAMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXMR { + bits: bool, +} +impl RXMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXMR { + bits: bool, +} +impl TXMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SLAKIR { + bits: bool, +} +impl SLAKIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WKUIR { + bits: bool, +} +impl WKUIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIR { + bits: bool, +} +impl ERRIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SLAKR { + bits: bool, +} +impl SLAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INAKR { + bits: bool, +} +impl INAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SLAKIW<'a> { + w: &'a mut W, +} +impl<'a> _SLAKIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WKUIW<'a> { + w: &'a mut W, +} +impl<'a> _WKUIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 11 - RX"] + #[inline] + pub fn rx(&self) -> RXR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXR { bits } + } + #[doc = "Bit 10 - SAMP"] + #[inline] + pub fn samp(&self) -> SAMPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAMPR { bits } + } + #[doc = "Bit 9 - RXM"] + #[inline] + pub fn rxm(&self) -> RXMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXMR { bits } + } + #[doc = "Bit 8 - TXM"] + #[inline] + pub fn txm(&self) -> TXMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXMR { bits } + } + #[doc = "Bit 4 - SLAKI"] + #[inline] + pub fn slaki(&self) -> SLAKIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SLAKIR { bits } + } + #[doc = "Bit 3 - WKUI"] + #[inline] + pub fn wkui(&self) -> WKUIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WKUIR { bits } + } + #[doc = "Bit 2 - ERRI"] + #[inline] + pub fn erri(&self) -> ERRIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIR { bits } + } + #[doc = "Bit 1 - SLAK"] + #[inline] + pub fn slak(&self) -> SLAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SLAKR { bits } + } + #[doc = "Bit 0 - INAK"] + #[inline] + pub fn inak(&self) -> INAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INAKR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 3074 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 4 - SLAKI"] + #[inline] + pub fn slaki(&mut self) -> _SLAKIW { + _SLAKIW { w: self } + } + #[doc = "Bit 3 - WKUI"] + #[inline] + pub fn wkui(&mut self) -> _WKUIW { + _WKUIW { w: self } + } + #[doc = "Bit 2 - ERRI"] + #[inline] + pub fn erri(&mut self) -> _ERRIW { + _ERRIW { w: self } + } +} diff --git a/src/can1/rdh0r/mod.rs b/src/can1/rdh0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0fef2953f4e2febf4ce6180c3e6469d85cc5a715 --- /dev/null +++ b/src/can1/rdh0r/mod.rs @@ -0,0 +1,104 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDH0R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATA7R { + bits: u8, +} +impl DATA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA6R { + bits: u8, +} +impl DATA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA5R { + bits: u8, +} +impl DATA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA4R { + bits: u8, +} +impl DATA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&self) -> DATA7R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA7R { bits } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&self) -> DATA6R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA6R { bits } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&self) -> DATA5R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA5R { bits } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&self) -> DATA4R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA4R { bits } + } +} diff --git a/src/can1/rdh1r/mod.rs b/src/can1/rdh1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6385c1649b84fc8ab5dfe5a99b0dcbeadece25f1 --- /dev/null +++ b/src/can1/rdh1r/mod.rs @@ -0,0 +1,104 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDH1R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATA7R { + bits: u8, +} +impl DATA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA6R { + bits: u8, +} +impl DATA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA5R { + bits: u8, +} +impl DATA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA4R { + bits: u8, +} +impl DATA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&self) -> DATA7R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA7R { bits } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&self) -> DATA6R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA6R { bits } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&self) -> DATA5R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA5R { bits } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&self) -> DATA4R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA4R { bits } + } +} diff --git a/src/can1/rdl0r/mod.rs b/src/can1/rdl0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7f0c67a156bc66b00b2392e64bb65f512935a29f --- /dev/null +++ b/src/can1/rdl0r/mod.rs @@ -0,0 +1,104 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDL0R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATA3R { + bits: u8, +} +impl DATA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA2R { + bits: u8, +} +impl DATA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA1R { + bits: u8, +} +impl DATA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA0R { + bits: u8, +} +impl DATA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&self) -> DATA3R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA3R { bits } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&self) -> DATA2R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA2R { bits } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&self) -> DATA1R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA1R { bits } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&self) -> DATA0R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA0R { bits } + } +} diff --git a/src/can1/rdl1r/mod.rs b/src/can1/rdl1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..64d7ef82246aae886eb4b93f3e50cafa4b0e496f --- /dev/null +++ b/src/can1/rdl1r/mod.rs @@ -0,0 +1,104 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDL1R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATA3R { + bits: u8, +} +impl DATA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA2R { + bits: u8, +} +impl DATA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA1R { + bits: u8, +} +impl DATA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA0R { + bits: u8, +} +impl DATA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&self) -> DATA3R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA3R { bits } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&self) -> DATA2R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA2R { bits } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&self) -> DATA1R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA1R { bits } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&self) -> DATA0R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA0R { bits } + } +} diff --git a/src/can1/rdt0r/mod.rs b/src/can1/rdt0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a5d3ffd84a1b45b8fc7de0bcd71918996be49d91 --- /dev/null +++ b/src/can1/rdt0r/mod.rs @@ -0,0 +1,83 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDT0R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct TIMER { + bits: u16, +} +impl TIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FMIR { + bits: u8, +} +impl FMIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DLCR { + bits: u8, +} +impl DLCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&self) -> TIMER { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMER { bits } + } + #[doc = "Bits 8:15 - FMI"] + #[inline] + pub fn fmi(&self) -> FMIR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FMIR { bits } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&self) -> DLCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DLCR { bits } + } +} diff --git a/src/can1/rdt1r/mod.rs b/src/can1/rdt1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61269da464cda270fb12437322fb4bd069904a03 --- /dev/null +++ b/src/can1/rdt1r/mod.rs @@ -0,0 +1,83 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RDT1R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct TIMER { + bits: u16, +} +impl TIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FMIR { + bits: u8, +} +impl FMIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DLCR { + bits: u8, +} +impl DLCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&self) -> TIMER { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMER { bits } + } + #[doc = "Bits 8:15 - FMI"] + #[inline] + pub fn fmi(&self) -> FMIR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FMIR { bits } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&self) -> DLCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DLCR { bits } + } +} diff --git a/src/can1/rf0r/mod.rs b/src/can1/rf0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bc32ec433530045e18dffd8aadce543312a8d822 --- /dev/null +++ b/src/can1/rf0r/mod.rs @@ -0,0 +1,262 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::RF0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RFOM0R { + bits: bool, +} +impl RFOM0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FOVR0R { + bits: bool, +} +impl FOVR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FULL0R { + bits: bool, +} +impl FULL0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMP0R { + bits: u8, +} +impl FMP0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RFOM0W<'a> { + w: &'a mut W, +} +impl<'a> _RFOM0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOVR0W<'a> { + w: &'a mut W, +} +impl<'a> _FOVR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FULL0W<'a> { + w: &'a mut W, +} +impl<'a> _FULL0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 5 - RFOM0"] + #[inline] + pub fn rfom0(&self) -> RFOM0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RFOM0R { bits } + } + #[doc = "Bit 4 - FOVR0"] + #[inline] + pub fn fovr0(&self) -> FOVR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FOVR0R { bits } + } + #[doc = "Bit 3 - FULL0"] + #[inline] + pub fn full0(&self) -> FULL0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FULL0R { bits } + } + #[doc = "Bits 0:1 - FMP0"] + #[inline] + pub fn fmp0(&self) -> FMP0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FMP0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - RFOM0"] + #[inline] + pub fn rfom0(&mut self) -> _RFOM0W { + _RFOM0W { w: self } + } + #[doc = "Bit 4 - FOVR0"] + #[inline] + pub fn fovr0(&mut self) -> _FOVR0W { + _FOVR0W { w: self } + } + #[doc = "Bit 3 - FULL0"] + #[inline] + pub fn full0(&mut self) -> _FULL0W { + _FULL0W { w: self } + } +} diff --git a/src/can1/rf1r/mod.rs b/src/can1/rf1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4046bcb9b4ba572384d30b80e01558d518d1c043 --- /dev/null +++ b/src/can1/rf1r/mod.rs @@ -0,0 +1,262 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::RF1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RFOM1R { + bits: bool, +} +impl RFOM1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FOVR1R { + bits: bool, +} +impl FOVR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FULL1R { + bits: bool, +} +impl FULL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMP1R { + bits: u8, +} +impl FMP1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RFOM1W<'a> { + w: &'a mut W, +} +impl<'a> _RFOM1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOVR1W<'a> { + w: &'a mut W, +} +impl<'a> _FOVR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FULL1W<'a> { + w: &'a mut W, +} +impl<'a> _FULL1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 5 - RFOM1"] + #[inline] + pub fn rfom1(&self) -> RFOM1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RFOM1R { bits } + } + #[doc = "Bit 4 - FOVR1"] + #[inline] + pub fn fovr1(&self) -> FOVR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FOVR1R { bits } + } + #[doc = "Bit 3 - FULL1"] + #[inline] + pub fn full1(&self) -> FULL1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FULL1R { bits } + } + #[doc = "Bits 0:1 - FMP1"] + #[inline] + pub fn fmp1(&self) -> FMP1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FMP1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - RFOM1"] + #[inline] + pub fn rfom1(&mut self) -> _RFOM1W { + _RFOM1W { w: self } + } + #[doc = "Bit 4 - FOVR1"] + #[inline] + pub fn fovr1(&mut self) -> _FOVR1W { + _FOVR1W { w: self } + } + #[doc = "Bit 3 - FULL1"] + #[inline] + pub fn full1(&mut self) -> _FULL1W { + _FULL1W { w: self } + } +} diff --git a/src/can1/ri0r/mod.rs b/src/can1/ri0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f4372954fb552b8c06bbce972e92ea070a25f153 --- /dev/null +++ b/src/can1/ri0r/mod.rs @@ -0,0 +1,124 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RI0R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct STIDR { + bits: u16, +} +impl STIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXIDR { + bits: u32, +} +impl EXIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IDER { + bits: bool, +} +impl IDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTRR { + bits: bool, +} +impl RTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&self) -> STIDR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + STIDR { bits } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&self) -> EXIDR { + let bits = { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXIDR { bits } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&self) -> IDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDER { bits } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&self) -> RTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTRR { bits } + } +} diff --git a/src/can1/ri1r/mod.rs b/src/can1/ri1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e26698a43163282fb9cead291482b8bdb78943ec --- /dev/null +++ b/src/can1/ri1r/mod.rs @@ -0,0 +1,124 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RI1R { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct STIDR { + bits: u16, +} +impl STIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXIDR { + bits: u32, +} +impl EXIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IDER { + bits: bool, +} +impl IDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTRR { + bits: bool, +} +impl RTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&self) -> STIDR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + STIDR { bits } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&self) -> EXIDR { + let bits = { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXIDR { bits } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&self) -> IDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDER { bits } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&self) -> RTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTRR { bits } + } +} diff --git a/src/can1/tdh0r/mod.rs b/src/can1/tdh0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f408f34e39426f06b147702b5e4e06dc34200f80 --- /dev/null +++ b/src/can1/tdh0r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDH0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA7R { + bits: u8, +} +impl DATA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA6R { + bits: u8, +} +impl DATA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA5R { + bits: u8, +} +impl DATA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA4R { + bits: u8, +} +impl DATA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA7W<'a> { + w: &'a mut W, +} +impl<'a> _DATA7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA6W<'a> { + w: &'a mut W, +} +impl<'a> _DATA6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA5W<'a> { + w: &'a mut W, +} +impl<'a> _DATA5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA4W<'a> { + w: &'a mut W, +} +impl<'a> _DATA4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&self) -> DATA7R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA7R { bits } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&self) -> DATA6R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA6R { bits } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&self) -> DATA5R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA5R { bits } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&self) -> DATA4R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&mut self) -> _DATA7W { + _DATA7W { w: self } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&mut self) -> _DATA6W { + _DATA6W { w: self } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&mut self) -> _DATA5W { + _DATA5W { w: self } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&mut self) -> _DATA4W { + _DATA4W { w: self } + } +} diff --git a/src/can1/tdh1r/mod.rs b/src/can1/tdh1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7480f418e75e3fa4e4f89300068e5b8e1d5dc59f --- /dev/null +++ b/src/can1/tdh1r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDH1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA7R { + bits: u8, +} +impl DATA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA6R { + bits: u8, +} +impl DATA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA5R { + bits: u8, +} +impl DATA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA4R { + bits: u8, +} +impl DATA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA7W<'a> { + w: &'a mut W, +} +impl<'a> _DATA7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA6W<'a> { + w: &'a mut W, +} +impl<'a> _DATA6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA5W<'a> { + w: &'a mut W, +} +impl<'a> _DATA5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA4W<'a> { + w: &'a mut W, +} +impl<'a> _DATA4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&self) -> DATA7R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA7R { bits } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&self) -> DATA6R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA6R { bits } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&self) -> DATA5R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA5R { bits } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&self) -> DATA4R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&mut self) -> _DATA7W { + _DATA7W { w: self } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&mut self) -> _DATA6W { + _DATA6W { w: self } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&mut self) -> _DATA5W { + _DATA5W { w: self } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&mut self) -> _DATA4W { + _DATA4W { w: self } + } +} diff --git a/src/can1/tdh2r/mod.rs b/src/can1/tdh2r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..111bf748b9826fda621aff18cf35744023cff10b --- /dev/null +++ b/src/can1/tdh2r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDH2R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA7R { + bits: u8, +} +impl DATA7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA6R { + bits: u8, +} +impl DATA6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA5R { + bits: u8, +} +impl DATA5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA4R { + bits: u8, +} +impl DATA4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA7W<'a> { + w: &'a mut W, +} +impl<'a> _DATA7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA6W<'a> { + w: &'a mut W, +} +impl<'a> _DATA6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA5W<'a> { + w: &'a mut W, +} +impl<'a> _DATA5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA4W<'a> { + w: &'a mut W, +} +impl<'a> _DATA4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&self) -> DATA7R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA7R { bits } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&self) -> DATA6R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA6R { bits } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&self) -> DATA5R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA5R { bits } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&self) -> DATA4R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA7"] + #[inline] + pub fn data7(&mut self) -> _DATA7W { + _DATA7W { w: self } + } + #[doc = "Bits 16:23 - DATA6"] + #[inline] + pub fn data6(&mut self) -> _DATA6W { + _DATA6W { w: self } + } + #[doc = "Bits 8:15 - DATA5"] + #[inline] + pub fn data5(&mut self) -> _DATA5W { + _DATA5W { w: self } + } + #[doc = "Bits 0:7 - DATA4"] + #[inline] + pub fn data4(&mut self) -> _DATA4W { + _DATA4W { w: self } + } +} diff --git a/src/can1/tdl0r/mod.rs b/src/can1/tdl0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7d13751f56e5e082732a1f246f3f077751adfc32 --- /dev/null +++ b/src/can1/tdl0r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDL0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA3R { + bits: u8, +} +impl DATA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA2R { + bits: u8, +} +impl DATA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA1R { + bits: u8, +} +impl DATA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA0R { + bits: u8, +} +impl DATA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA3W<'a> { + w: &'a mut W, +} +impl<'a> _DATA3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA2W<'a> { + w: &'a mut W, +} +impl<'a> _DATA2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA1W<'a> { + w: &'a mut W, +} +impl<'a> _DATA1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA0W<'a> { + w: &'a mut W, +} +impl<'a> _DATA0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&self) -> DATA3R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA3R { bits } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&self) -> DATA2R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA2R { bits } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&self) -> DATA1R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA1R { bits } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&self) -> DATA0R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&mut self) -> _DATA3W { + _DATA3W { w: self } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&mut self) -> _DATA2W { + _DATA2W { w: self } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&mut self) -> _DATA1W { + _DATA1W { w: self } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&mut self) -> _DATA0W { + _DATA0W { w: self } + } +} diff --git a/src/can1/tdl1r/mod.rs b/src/can1/tdl1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..39c3d0fe8eed68e267a19aa3114b84e1e3c6b3a0 --- /dev/null +++ b/src/can1/tdl1r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDL1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA3R { + bits: u8, +} +impl DATA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA2R { + bits: u8, +} +impl DATA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA1R { + bits: u8, +} +impl DATA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA0R { + bits: u8, +} +impl DATA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA3W<'a> { + w: &'a mut W, +} +impl<'a> _DATA3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA2W<'a> { + w: &'a mut W, +} +impl<'a> _DATA2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA1W<'a> { + w: &'a mut W, +} +impl<'a> _DATA1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA0W<'a> { + w: &'a mut W, +} +impl<'a> _DATA0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&self) -> DATA3R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA3R { bits } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&self) -> DATA2R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA2R { bits } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&self) -> DATA1R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA1R { bits } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&self) -> DATA0R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&mut self) -> _DATA3W { + _DATA3W { w: self } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&mut self) -> _DATA2W { + _DATA2W { w: self } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&mut self) -> _DATA1W { + _DATA1W { w: self } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&mut self) -> _DATA0W { + _DATA0W { w: self } + } +} diff --git a/src/can1/tdl2r/mod.rs b/src/can1/tdl2r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ec623d28c4053bb06713f83973a61ffd92bf5509 --- /dev/null +++ b/src/can1/tdl2r/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDL2R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATA3R { + bits: u8, +} +impl DATA3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA2R { + bits: u8, +} +impl DATA2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA1R { + bits: u8, +} +impl DATA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATA0R { + bits: u8, +} +impl DATA0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATA3W<'a> { + w: &'a mut W, +} +impl<'a> _DATA3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA2W<'a> { + w: &'a mut W, +} +impl<'a> _DATA2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA1W<'a> { + w: &'a mut W, +} +impl<'a> _DATA1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATA0W<'a> { + w: &'a mut W, +} +impl<'a> _DATA0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&self) -> DATA3R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA3R { bits } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&self) -> DATA2R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA2R { bits } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&self) -> DATA1R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA1R { bits } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&self) -> DATA0R { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATA0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - DATA3"] + #[inline] + pub fn data3(&mut self) -> _DATA3W { + _DATA3W { w: self } + } + #[doc = "Bits 16:23 - DATA2"] + #[inline] + pub fn data2(&mut self) -> _DATA2W { + _DATA2W { w: self } + } + #[doc = "Bits 8:15 - DATA1"] + #[inline] + pub fn data1(&mut self) -> _DATA1W { + _DATA1W { w: self } + } + #[doc = "Bits 0:7 - DATA0"] + #[inline] + pub fn data0(&mut self) -> _DATA0W { + _DATA0W { w: self } + } +} diff --git a/src/can1/tdt0r/mod.rs b/src/can1/tdt0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a51e4d10d945bc3d186b2035cb36edab08345199 --- /dev/null +++ b/src/can1/tdt0r/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDT0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIMER { + bits: u16, +} +impl TIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TGTR { + bits: bool, +} +impl TGTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DLCR { + bits: u8, +} +impl DLCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TIMEW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TGTW<'a> { + w: &'a mut W, +} +impl<'a> _TGTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DLCW<'a> { + w: &'a mut W, +} +impl<'a> _DLCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&self) -> TIMER { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMER { bits } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&self) -> TGTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TGTR { bits } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&self) -> DLCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DLCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&mut self) -> _TIMEW { + _TIMEW { w: self } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&mut self) -> _TGTW { + _TGTW { w: self } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&mut self) -> _DLCW { + _DLCW { w: self } + } +} diff --git a/src/can1/tdt1r/mod.rs b/src/can1/tdt1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ddf6e8e139409fe94c44355c79f7e12bc2b7e7ef --- /dev/null +++ b/src/can1/tdt1r/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDT1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIMER { + bits: u16, +} +impl TIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TGTR { + bits: bool, +} +impl TGTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DLCR { + bits: u8, +} +impl DLCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TIMEW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TGTW<'a> { + w: &'a mut W, +} +impl<'a> _TGTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DLCW<'a> { + w: &'a mut W, +} +impl<'a> _DLCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&self) -> TIMER { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMER { bits } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&self) -> TGTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TGTR { bits } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&self) -> DLCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DLCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&mut self) -> _TIMEW { + _TIMEW { w: self } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&mut self) -> _TGTW { + _TGTW { w: self } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&mut self) -> _DLCW { + _DLCW { w: self } + } +} diff --git a/src/can1/tdt2r/mod.rs b/src/can1/tdt2r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c32f0e360cbc2195622dc30f778851c9a9920c84 --- /dev/null +++ b/src/can1/tdt2r/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TDT2R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIMER { + bits: u16, +} +impl TIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TGTR { + bits: bool, +} +impl TGTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DLCR { + bits: u8, +} +impl DLCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TIMEW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TGTW<'a> { + w: &'a mut W, +} +impl<'a> _TGTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DLCW<'a> { + w: &'a mut W, +} +impl<'a> _DLCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&self) -> TIMER { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMER { bits } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&self) -> TGTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TGTR { bits } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&self) -> DLCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DLCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - TIME"] + #[inline] + pub fn time(&mut self) -> _TIMEW { + _TIMEW { w: self } + } + #[doc = "Bit 8 - TGT"] + #[inline] + pub fn tgt(&mut self) -> _TGTW { + _TGTW { w: self } + } + #[doc = "Bits 0:3 - DLC"] + #[inline] + pub fn dlc(&mut self) -> _DLCW { + _DLCW { w: self } + } +} diff --git a/src/can1/ti0r/mod.rs b/src/can1/ti0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fbc7fe37a817d3dc988091f20fc858ca73f86dc6 --- /dev/null +++ b/src/can1/ti0r/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TI0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct STIDR { + bits: u16, +} +impl STIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXIDR { + bits: u32, +} +impl EXIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IDER { + bits: bool, +} +impl IDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTRR { + bits: bool, +} +impl RTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXRQR { + bits: bool, +} +impl TXRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _STIDW<'a> { + w: &'a mut W, +} +impl<'a> _STIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXIDW<'a> { + w: &'a mut W, +} +impl<'a> _EXIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IDEW<'a> { + w: &'a mut W, +} +impl<'a> _IDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTRW<'a> { + w: &'a mut W, +} +impl<'a> _RTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXRQW<'a> { + w: &'a mut W, +} +impl<'a> _TXRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&self) -> STIDR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + STIDR { bits } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&self) -> EXIDR { + let bits = { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXIDR { bits } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&self) -> IDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDER { bits } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&self) -> RTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTRR { bits } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&self) -> TXRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXRQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&mut self) -> _STIDW { + _STIDW { w: self } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&mut self) -> _EXIDW { + _EXIDW { w: self } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&mut self) -> _IDEW { + _IDEW { w: self } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&mut self) -> _RTRW { + _RTRW { w: self } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&mut self) -> _TXRQW { + _TXRQW { w: self } + } +} diff --git a/src/can1/ti1r/mod.rs b/src/can1/ti1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3473e4e1fb0fe3ba7b77d4ec0cab1b2a8a135345 --- /dev/null +++ b/src/can1/ti1r/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TI1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct STIDR { + bits: u16, +} +impl STIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXIDR { + bits: u32, +} +impl EXIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IDER { + bits: bool, +} +impl IDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTRR { + bits: bool, +} +impl RTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXRQR { + bits: bool, +} +impl TXRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _STIDW<'a> { + w: &'a mut W, +} +impl<'a> _STIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXIDW<'a> { + w: &'a mut W, +} +impl<'a> _EXIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IDEW<'a> { + w: &'a mut W, +} +impl<'a> _IDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTRW<'a> { + w: &'a mut W, +} +impl<'a> _RTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXRQW<'a> { + w: &'a mut W, +} +impl<'a> _TXRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&self) -> STIDR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + STIDR { bits } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&self) -> EXIDR { + let bits = { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXIDR { bits } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&self) -> IDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDER { bits } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&self) -> RTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTRR { bits } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&self) -> TXRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXRQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&mut self) -> _STIDW { + _STIDW { w: self } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&mut self) -> _EXIDW { + _EXIDW { w: self } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&mut self) -> _IDEW { + _IDEW { w: self } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&mut self) -> _RTRW { + _RTRW { w: self } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&mut self) -> _TXRQW { + _TXRQW { w: self } + } +} diff --git a/src/can1/ti2r/mod.rs b/src/can1/ti2r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8d669a94e0b337a54aa510a9ab49dc68d2def61 --- /dev/null +++ b/src/can1/ti2r/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TI2R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct STIDR { + bits: u16, +} +impl STIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXIDR { + bits: u32, +} +impl EXIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IDER { + bits: bool, +} +impl IDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTRR { + bits: bool, +} +impl RTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXRQR { + bits: bool, +} +impl TXRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _STIDW<'a> { + w: &'a mut W, +} +impl<'a> _STIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXIDW<'a> { + w: &'a mut W, +} +impl<'a> _EXIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IDEW<'a> { + w: &'a mut W, +} +impl<'a> _IDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTRW<'a> { + w: &'a mut W, +} +impl<'a> _RTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXRQW<'a> { + w: &'a mut W, +} +impl<'a> _TXRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&self) -> STIDR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + STIDR { bits } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&self) -> EXIDR { + let bits = { + const MASK: u32 = 262143; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXIDR { bits } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&self) -> IDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDER { bits } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&self) -> RTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTRR { bits } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&self) -> TXRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXRQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 21:31 - STID"] + #[inline] + pub fn stid(&mut self) -> _STIDW { + _STIDW { w: self } + } + #[doc = "Bits 3:20 - EXID"] + #[inline] + pub fn exid(&mut self) -> _EXIDW { + _EXIDW { w: self } + } + #[doc = "Bit 2 - IDE"] + #[inline] + pub fn ide(&mut self) -> _IDEW { + _IDEW { w: self } + } + #[doc = "Bit 1 - RTR"] + #[inline] + pub fn rtr(&mut self) -> _RTRW { + _RTRW { w: self } + } + #[doc = "Bit 0 - TXRQ"] + #[inline] + pub fn txrq(&mut self) -> _TXRQW { + _TXRQW { w: self } + } +} diff --git a/src/can1/tsr/mod.rs b/src/can1/tsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..984764b4f39189f77c311596e9ab7662735219f9 --- /dev/null +++ b/src/can1/tsr/mod.rs @@ -0,0 +1,1156 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LOW2R { + bits: bool, +} +impl LOW2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LOW1R { + bits: bool, +} +impl LOW1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LOW0R { + bits: bool, +} +impl LOW0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TME2R { + bits: bool, +} +impl TME2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TME1R { + bits: bool, +} +impl TME1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TME0R { + bits: bool, +} +impl TME0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CODER { + bits: u8, +} +impl CODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ABRQ2R { + bits: bool, +} +impl ABRQ2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TERR2R { + bits: bool, +} +impl TERR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALST2R { + bits: bool, +} +impl ALST2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXOK2R { + bits: bool, +} +impl TXOK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RQCP2R { + bits: bool, +} +impl RQCP2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ABRQ1R { + bits: bool, +} +impl ABRQ1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TERR1R { + bits: bool, +} +impl TERR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALST1R { + bits: bool, +} +impl ALST1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXOK1R { + bits: bool, +} +impl TXOK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RQCP1R { + bits: bool, +} +impl RQCP1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ABRQ0R { + bits: bool, +} +impl ABRQ0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TERR0R { + bits: bool, +} +impl TERR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALST0R { + bits: bool, +} +impl ALST0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXOK0R { + bits: bool, +} +impl TXOK0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RQCP0R { + bits: bool, +} +impl RQCP0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ABRQ2W<'a> { + w: &'a mut W, +} +impl<'a> _ABRQ2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TERR2W<'a> { + w: &'a mut W, +} +impl<'a> _TERR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALST2W<'a> { + w: &'a mut W, +} +impl<'a> _ALST2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXOK2W<'a> { + w: &'a mut W, +} +impl<'a> _TXOK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RQCP2W<'a> { + w: &'a mut W, +} +impl<'a> _RQCP2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABRQ1W<'a> { + w: &'a mut W, +} +impl<'a> _ABRQ1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TERR1W<'a> { + w: &'a mut W, +} +impl<'a> _TERR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALST1W<'a> { + w: &'a mut W, +} +impl<'a> _ALST1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXOK1W<'a> { + w: &'a mut W, +} +impl<'a> _TXOK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RQCP1W<'a> { + w: &'a mut W, +} +impl<'a> _RQCP1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABRQ0W<'a> { + w: &'a mut W, +} +impl<'a> _ABRQ0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TERR0W<'a> { + w: &'a mut W, +} +impl<'a> _TERR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALST0W<'a> { + w: &'a mut W, +} +impl<'a> _ALST0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXOK0W<'a> { + w: &'a mut W, +} +impl<'a> _TXOK0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RQCP0W<'a> { + w: &'a mut W, +} +impl<'a> _RQCP0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Lowest priority flag for mailbox 2"] + #[inline] + pub fn low2(&self) -> LOW2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LOW2R { bits } + } + #[doc = "Bit 30 - Lowest priority flag for mailbox 1"] + #[inline] + pub fn low1(&self) -> LOW1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LOW1R { bits } + } + #[doc = "Bit 29 - Lowest priority flag for mailbox 0"] + #[inline] + pub fn low0(&self) -> LOW0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LOW0R { bits } + } + #[doc = "Bit 28 - Lowest priority flag for mailbox 2"] + #[inline] + pub fn tme2(&self) -> TME2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TME2R { bits } + } + #[doc = "Bit 27 - Lowest priority flag for mailbox 1"] + #[inline] + pub fn tme1(&self) -> TME1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TME1R { bits } + } + #[doc = "Bit 26 - Lowest priority flag for mailbox 0"] + #[inline] + pub fn tme0(&self) -> TME0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TME0R { bits } + } + #[doc = "Bits 24:25 - CODE"] + #[inline] + pub fn code(&self) -> CODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CODER { bits } + } + #[doc = "Bit 23 - ABRQ2"] + #[inline] + pub fn abrq2(&self) -> ABRQ2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ABRQ2R { bits } + } + #[doc = "Bit 19 - TERR2"] + #[inline] + pub fn terr2(&self) -> TERR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TERR2R { bits } + } + #[doc = "Bit 18 - ALST2"] + #[inline] + pub fn alst2(&self) -> ALST2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALST2R { bits } + } + #[doc = "Bit 17 - TXOK2"] + #[inline] + pub fn txok2(&self) -> TXOK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXOK2R { bits } + } + #[doc = "Bit 16 - RQCP2"] + #[inline] + pub fn rqcp2(&self) -> RQCP2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RQCP2R { bits } + } + #[doc = "Bit 15 - ABRQ1"] + #[inline] + pub fn abrq1(&self) -> ABRQ1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ABRQ1R { bits } + } + #[doc = "Bit 11 - TERR1"] + #[inline] + pub fn terr1(&self) -> TERR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TERR1R { bits } + } + #[doc = "Bit 10 - ALST1"] + #[inline] + pub fn alst1(&self) -> ALST1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALST1R { bits } + } + #[doc = "Bit 9 - TXOK1"] + #[inline] + pub fn txok1(&self) -> TXOK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXOK1R { bits } + } + #[doc = "Bit 8 - RQCP1"] + #[inline] + pub fn rqcp1(&self) -> RQCP1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RQCP1R { bits } + } + #[doc = "Bit 7 - ABRQ0"] + #[inline] + pub fn abrq0(&self) -> ABRQ0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ABRQ0R { bits } + } + #[doc = "Bit 3 - TERR0"] + #[inline] + pub fn terr0(&self) -> TERR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TERR0R { bits } + } + #[doc = "Bit 2 - ALST0"] + #[inline] + pub fn alst0(&self) -> ALST0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALST0R { bits } + } + #[doc = "Bit 1 - TXOK0"] + #[inline] + pub fn txok0(&self) -> TXOK0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXOK0R { bits } + } + #[doc = "Bit 0 - RQCP0"] + #[inline] + pub fn rqcp0(&self) -> RQCP0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RQCP0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 469762048 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 23 - ABRQ2"] + #[inline] + pub fn abrq2(&mut self) -> _ABRQ2W { + _ABRQ2W { w: self } + } + #[doc = "Bit 19 - TERR2"] + #[inline] + pub fn terr2(&mut self) -> _TERR2W { + _TERR2W { w: self } + } + #[doc = "Bit 18 - ALST2"] + #[inline] + pub fn alst2(&mut self) -> _ALST2W { + _ALST2W { w: self } + } + #[doc = "Bit 17 - TXOK2"] + #[inline] + pub fn txok2(&mut self) -> _TXOK2W { + _TXOK2W { w: self } + } + #[doc = "Bit 16 - RQCP2"] + #[inline] + pub fn rqcp2(&mut self) -> _RQCP2W { + _RQCP2W { w: self } + } + #[doc = "Bit 15 - ABRQ1"] + #[inline] + pub fn abrq1(&mut self) -> _ABRQ1W { + _ABRQ1W { w: self } + } + #[doc = "Bit 11 - TERR1"] + #[inline] + pub fn terr1(&mut self) -> _TERR1W { + _TERR1W { w: self } + } + #[doc = "Bit 10 - ALST1"] + #[inline] + pub fn alst1(&mut self) -> _ALST1W { + _ALST1W { w: self } + } + #[doc = "Bit 9 - TXOK1"] + #[inline] + pub fn txok1(&mut self) -> _TXOK1W { + _TXOK1W { w: self } + } + #[doc = "Bit 8 - RQCP1"] + #[inline] + pub fn rqcp1(&mut self) -> _RQCP1W { + _RQCP1W { w: self } + } + #[doc = "Bit 7 - ABRQ0"] + #[inline] + pub fn abrq0(&mut self) -> _ABRQ0W { + _ABRQ0W { w: self } + } + #[doc = "Bit 3 - TERR0"] + #[inline] + pub fn terr0(&mut self) -> _TERR0W { + _TERR0W { w: self } + } + #[doc = "Bit 2 - ALST0"] + #[inline] + pub fn alst0(&mut self) -> _ALST0W { + _ALST0W { w: self } + } + #[doc = "Bit 1 - TXOK0"] + #[inline] + pub fn txok0(&mut self) -> _TXOK0W { + _TXOK0W { w: self } + } + #[doc = "Bit 0 - RQCP0"] + #[inline] + pub fn rqcp0(&mut self) -> _RQCP0W { + _RQCP0W { w: self } + } +} diff --git a/src/crc/cr/mod.rs b/src/crc/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..66e7d54c994b590e7b63234b7894acb84a0f7ecc --- /dev/null +++ b/src/crc/cr/mod.rs @@ -0,0 +1,57 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CRW<'a> { + w: &'a mut W, +} +impl<'a> _CRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Control regidter"] + #[inline] + pub fn cr(&mut self) -> _CRW { + _CRW { w: self } + } +} diff --git a/src/crc/dr/mod.rs b/src/crc/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dc19159d1efa301cfa1e160d5ace7caae2a653a3 --- /dev/null +++ b/src/crc/dr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DRR { + bits: u32, +} +impl DRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DRW<'a> { + w: &'a mut W, +} +impl<'a> _DRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data Register"] + #[inline] + pub fn dr(&self) -> DRR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4294967295 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data Register"] + #[inline] + pub fn dr(&mut self) -> _DRW { + _DRW { w: self } + } +} diff --git a/src/crc/idr/mod.rs b/src/crc/idr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..10fcf17de0d6b592fe70c85f79c7d3f354b3b81d --- /dev/null +++ b/src/crc/idr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IDRR { + bits: u8, +} +impl IDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IDRW<'a> { + w: &'a mut W, +} +impl<'a> _IDRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Independent Data register"] + #[inline] + pub fn idr(&self) -> IDRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IDRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Independent Data register"] + #[inline] + pub fn idr(&mut self) -> _IDRW { + _IDRW { w: self } + } +} diff --git a/src/crc/mod.rs b/src/crc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0cc2e2e69bcfe3aa5dd51cfa5022bd57f5d033f5 --- /dev/null +++ b/src/crc/mod.rs @@ -0,0 +1,28 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Data register"] + pub dr: DR, + #[doc = "0x04 - Independent Data register"] + pub idr: IDR, + #[doc = "0x08 - Control register"] + pub cr: CR, +} +#[doc = "Data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Data register"] +pub mod dr; +#[doc = "Independent Data register"] +pub struct IDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Independent Data register"] +pub mod idr; +#[doc = "Control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register"] +pub mod cr; diff --git a/src/dac/cr/mod.rs b/src/dac/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d0f38e832dfe5849112639a3258189b6f1fac543 --- /dev/null +++ b/src/dac/cr/mod.rs @@ -0,0 +1,900 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMAUDRIE2R { + bits: bool, +} +impl DMAUDRIE2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAEN2R { + bits: bool, +} +impl DMAEN2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MAMP2R { + bits: u8, +} +impl MAMP2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct WAVE2R { + bits: u8, +} +impl WAVE2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TSEL2R { + bits: u8, +} +impl TSEL2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TEN2R { + bits: bool, +} +impl TEN2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BOFF2R { + bits: bool, +} +impl BOFF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EN2R { + bits: bool, +} +impl EN2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAUDRIE1R { + bits: bool, +} +impl DMAUDRIE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAEN1R { + bits: bool, +} +impl DMAEN1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MAMP1R { + bits: u8, +} +impl MAMP1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct WAVE1R { + bits: u8, +} +impl WAVE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TSEL1R { + bits: u8, +} +impl TSEL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TEN1R { + bits: bool, +} +impl TEN1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BOFF1R { + bits: bool, +} +impl BOFF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EN1R { + bits: bool, +} +impl EN1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DMAUDRIE2W<'a> { + w: &'a mut W, +} +impl<'a> _DMAUDRIE2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAEN2W<'a> { + w: &'a mut W, +} +impl<'a> _DMAEN2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MAMP2W<'a> { + w: &'a mut W, +} +impl<'a> _MAMP2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAVE2W<'a> { + w: &'a mut W, +} +impl<'a> _WAVE2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSEL2W<'a> { + w: &'a mut W, +} +impl<'a> _TSEL2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEN2W<'a> { + w: &'a mut W, +} +impl<'a> _TEN2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BOFF2W<'a> { + w: &'a mut W, +} +impl<'a> _BOFF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EN2W<'a> { + w: &'a mut W, +} +impl<'a> _EN2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAUDRIE1W<'a> { + w: &'a mut W, +} +impl<'a> _DMAUDRIE1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAEN1W<'a> { + w: &'a mut W, +} +impl<'a> _DMAEN1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MAMP1W<'a> { + w: &'a mut W, +} +impl<'a> _MAMP1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAVE1W<'a> { + w: &'a mut W, +} +impl<'a> _WAVE1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSEL1W<'a> { + w: &'a mut W, +} +impl<'a> _TSEL1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEN1W<'a> { + w: &'a mut W, +} +impl<'a> _TEN1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BOFF1W<'a> { + w: &'a mut W, +} +impl<'a> _BOFF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EN1W<'a> { + w: &'a mut W, +} +impl<'a> _EN1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 29 - DAC channel2 DMA underrun interrupt enable"] + #[inline] + pub fn dmaudrie2(&self) -> DMAUDRIE2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAUDRIE2R { bits } + } + #[doc = "Bit 28 - DAC channel2 DMA enable"] + #[inline] + pub fn dmaen2(&self) -> DMAEN2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAEN2R { bits } + } + #[doc = "Bits 24:27 - DAC channel2 mask/amplitude selector"] + #[inline] + pub fn mamp2(&self) -> MAMP2R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MAMP2R { bits } + } + #[doc = "Bits 22:23 - DAC channel2 noise/triangle wave generation enable"] + #[inline] + pub fn wave2(&self) -> WAVE2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WAVE2R { bits } + } + #[doc = "Bits 19:21 - DAC channel2 trigger selection"] + #[inline] + pub fn tsel2(&self) -> TSEL2R { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSEL2R { bits } + } + #[doc = "Bit 18 - DAC channel2 trigger enable"] + #[inline] + pub fn ten2(&self) -> TEN2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEN2R { bits } + } + #[doc = "Bit 17 - DAC channel2 output buffer disable"] + #[inline] + pub fn boff2(&self) -> BOFF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BOFF2R { bits } + } + #[doc = "Bit 16 - DAC channel2 enable"] + #[inline] + pub fn en2(&self) -> EN2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EN2R { bits } + } + #[doc = "Bit 13 - DAC channel1 DMA Underrun Interrupt enable"] + #[inline] + pub fn dmaudrie1(&self) -> DMAUDRIE1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAUDRIE1R { bits } + } + #[doc = "Bit 12 - DAC channel1 DMA enable"] + #[inline] + pub fn dmaen1(&self) -> DMAEN1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAEN1R { bits } + } + #[doc = "Bits 8:11 - DAC channel1 mask/amplitude selector"] + #[inline] + pub fn mamp1(&self) -> MAMP1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MAMP1R { bits } + } + #[doc = "Bits 6:7 - DAC channel1 noise/triangle wave generation enable"] + #[inline] + pub fn wave1(&self) -> WAVE1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WAVE1R { bits } + } + #[doc = "Bits 3:5 - DAC channel1 trigger selection"] + #[inline] + pub fn tsel1(&self) -> TSEL1R { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSEL1R { bits } + } + #[doc = "Bit 2 - DAC channel1 trigger enable"] + #[inline] + pub fn ten1(&self) -> TEN1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEN1R { bits } + } + #[doc = "Bit 1 - DAC channel1 output buffer disable"] + #[inline] + pub fn boff1(&self) -> BOFF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BOFF1R { bits } + } + #[doc = "Bit 0 - DAC channel1 enable"] + #[inline] + pub fn en1(&self) -> EN1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EN1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 29 - DAC channel2 DMA underrun interrupt enable"] + #[inline] + pub fn dmaudrie2(&mut self) -> _DMAUDRIE2W { + _DMAUDRIE2W { w: self } + } + #[doc = "Bit 28 - DAC channel2 DMA enable"] + #[inline] + pub fn dmaen2(&mut self) -> _DMAEN2W { + _DMAEN2W { w: self } + } + #[doc = "Bits 24:27 - DAC channel2 mask/amplitude selector"] + #[inline] + pub fn mamp2(&mut self) -> _MAMP2W { + _MAMP2W { w: self } + } + #[doc = "Bits 22:23 - DAC channel2 noise/triangle wave generation enable"] + #[inline] + pub fn wave2(&mut self) -> _WAVE2W { + _WAVE2W { w: self } + } + #[doc = "Bits 19:21 - DAC channel2 trigger selection"] + #[inline] + pub fn tsel2(&mut self) -> _TSEL2W { + _TSEL2W { w: self } + } + #[doc = "Bit 18 - DAC channel2 trigger enable"] + #[inline] + pub fn ten2(&mut self) -> _TEN2W { + _TEN2W { w: self } + } + #[doc = "Bit 17 - DAC channel2 output buffer disable"] + #[inline] + pub fn boff2(&mut self) -> _BOFF2W { + _BOFF2W { w: self } + } + #[doc = "Bit 16 - DAC channel2 enable"] + #[inline] + pub fn en2(&mut self) -> _EN2W { + _EN2W { w: self } + } + #[doc = "Bit 13 - DAC channel1 DMA Underrun Interrupt enable"] + #[inline] + pub fn dmaudrie1(&mut self) -> _DMAUDRIE1W { + _DMAUDRIE1W { w: self } + } + #[doc = "Bit 12 - DAC channel1 DMA enable"] + #[inline] + pub fn dmaen1(&mut self) -> _DMAEN1W { + _DMAEN1W { w: self } + } + #[doc = "Bits 8:11 - DAC channel1 mask/amplitude selector"] + #[inline] + pub fn mamp1(&mut self) -> _MAMP1W { + _MAMP1W { w: self } + } + #[doc = "Bits 6:7 - DAC channel1 noise/triangle wave generation enable"] + #[inline] + pub fn wave1(&mut self) -> _WAVE1W { + _WAVE1W { w: self } + } + #[doc = "Bits 3:5 - DAC channel1 trigger selection"] + #[inline] + pub fn tsel1(&mut self) -> _TSEL1W { + _TSEL1W { w: self } + } + #[doc = "Bit 2 - DAC channel1 trigger enable"] + #[inline] + pub fn ten1(&mut self) -> _TEN1W { + _TEN1W { w: self } + } + #[doc = "Bit 1 - DAC channel1 output buffer disable"] + #[inline] + pub fn boff1(&mut self) -> _BOFF1W { + _BOFF1W { w: self } + } + #[doc = "Bit 0 - DAC channel1 enable"] + #[inline] + pub fn en1(&mut self) -> _EN1W { + _EN1W { w: self } + } +} diff --git a/src/dac/dhr12l1/mod.rs b/src/dac/dhr12l1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ce4d4a804ca142c2d7509f26403d864d6b5e6165 --- /dev/null +++ b/src/dac/dhr12l1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12L1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u16, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dhr12l2/mod.rs b/src/dac/dhr12l2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3d327dd43c71b7a54acbad92ff5f75c137d51142 --- /dev/null +++ b/src/dac/dhr12l2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12L2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u16, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:15 - DAC channel2 12-bit left-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC2DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:15 - DAC channel2 12-bit left-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } +} diff --git a/src/dac/dhr12ld/mod.rs b/src/dac/dhr12ld/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0c9df87553a3f60b9952f83d943295167af1798d --- /dev/null +++ b/src/dac/dhr12ld/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12LD { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u16, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u16, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:31 - DAC channel2 12-bit left-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC2DHRR { bits } + } + #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:31 - DAC channel2 12-bit left-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } + #[doc = "Bits 4:15 - DAC channel1 12-bit left-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dhr12r1/mod.rs b/src/dac/dhr12r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8e225566aa178d4ac1b626c235beeaedf671120 --- /dev/null +++ b/src/dac/dhr12r1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u16, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dhr12r2/mod.rs b/src/dac/dhr12r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..39b6498b690234e4fb375f58288265a8528ef9eb --- /dev/null +++ b/src/dac/dhr12r2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u16, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - DAC channel2 12-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC2DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - DAC channel2 12-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } +} diff --git a/src/dac/dhr12rd/mod.rs b/src/dac/dhr12rd/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2fd5d8f5d7d015e1fa3bf41b744f62516a382333 --- /dev/null +++ b/src/dac/dhr12rd/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR12RD { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u16, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u16, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:27 - DAC channel2 12-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC2DHRR { bits } + } + #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:27 - DAC channel2 12-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } + #[doc = "Bits 0:11 - DAC channel1 12-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dhr8r1/mod.rs b/src/dac/dhr8r1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4474b592845c6d0b73411e9fdf5bb687451fd459 --- /dev/null +++ b/src/dac/dhr8r1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR8R1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u8, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dhr8r2/mod.rs b/src/dac/dhr8r2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7de7c3d7016e8f222fa579a734164b94b71db7d6 --- /dev/null +++ b/src/dac/dhr8r2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR8R2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u8, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - DAC channel2 8-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DACC2DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - DAC channel2 8-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } +} diff --git a/src/dac/dhr8rd/mod.rs b/src/dac/dhr8rd/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6104fb4c58a0654be42902cffcc5d9ff8f5e9dbb --- /dev/null +++ b/src/dac/dhr8rd/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DHR8RD { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DACC2DHRR { + bits: u8, +} +impl DACC2DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DACC1DHRR { + bits: u8, +} +impl DACC1DHRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DACC2DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC2DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACC1DHRW<'a> { + w: &'a mut W, +} +impl<'a> _DACC1DHRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - DAC channel2 8-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&self) -> DACC2DHRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DACC2DHRR { bits } + } + #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&self) -> DACC1DHRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DACC1DHRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - DAC channel2 8-bit right-aligned data"] + #[inline] + pub fn dacc2dhr(&mut self) -> _DACC2DHRW { + _DACC2DHRW { w: self } + } + #[doc = "Bits 0:7 - DAC channel1 8-bit right-aligned data"] + #[inline] + pub fn dacc1dhr(&mut self) -> _DACC1DHRW { + _DACC1DHRW { w: self } + } +} diff --git a/src/dac/dor1/mod.rs b/src/dac/dor1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..170ad2ef23d7d8fc64581823a7b1e46eced8a5e3 --- /dev/null +++ b/src/dac/dor1/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DOR1 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DACC1DORR { + bits: u16, +} +impl DACC1DORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - DAC channel1 data output"] + #[inline] + pub fn dacc1dor(&self) -> DACC1DORR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC1DORR { bits } + } +} diff --git a/src/dac/dor2/mod.rs b/src/dac/dor2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..af827a2933e4793ef4ebd8b92c76ef92bae6afbc --- /dev/null +++ b/src/dac/dor2/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DOR2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DACC2DORR { + bits: u16, +} +impl DACC2DORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - DAC channel2 data output"] + #[inline] + pub fn dacc2dor(&self) -> DACC2DORR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DACC2DORR { bits } + } +} diff --git a/src/dac/mod.rs b/src/dac/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19ab20e93712668e300e6ccff4ad23e81e2eb67a --- /dev/null +++ b/src/dac/mod.rs @@ -0,0 +1,116 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register"] + pub cr: CR, + #[doc = "0x04 - software trigger register"] + pub swtrigr: SWTRIGR, + #[doc = "0x08 - channel1 12-bit right-aligned data holding register"] + pub dhr12r1: DHR12R1, + #[doc = "0x0c - channel1 12-bit left aligned data holding register"] + pub dhr12l1: DHR12L1, + #[doc = "0x10 - channel1 8-bit right aligned data holding register"] + pub dhr8r1: DHR8R1, + #[doc = "0x14 - channel2 12-bit right aligned data holding register"] + pub dhr12r2: DHR12R2, + #[doc = "0x18 - channel2 12-bit left aligned data holding register"] + pub dhr12l2: DHR12L2, + #[doc = "0x1c - channel2 8-bit right-aligned data holding register"] + pub dhr8r2: DHR8R2, + #[doc = "0x20 - Dual DAC 12-bit right-aligned data holding register"] + pub dhr12rd: DHR12RD, + #[doc = "0x24 - DUAL DAC 12-bit left aligned data holding register"] + pub dhr12ld: DHR12LD, + #[doc = "0x28 - DUAL DAC 8-bit right aligned data holding register"] + pub dhr8rd: DHR8RD, + #[doc = "0x2c - channel1 data output register"] + pub dor1: DOR1, + #[doc = "0x30 - channel2 data output register"] + pub dor2: DOR2, + #[doc = "0x34 - status register"] + pub sr: SR, +} +#[doc = "control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register"] +pub mod cr; +#[doc = "software trigger register"] +pub struct SWTRIGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "software trigger register"] +pub mod swtrigr; +#[doc = "channel1 12-bit right-aligned data holding register"] +pub struct DHR12R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel1 12-bit right-aligned data holding register"] +pub mod dhr12r1; +#[doc = "channel1 12-bit left aligned data holding register"] +pub struct DHR12L1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel1 12-bit left aligned data holding register"] +pub mod dhr12l1; +#[doc = "channel1 8-bit right aligned data holding register"] +pub struct DHR8R1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel1 8-bit right aligned data holding register"] +pub mod dhr8r1; +#[doc = "channel2 12-bit right aligned data holding register"] +pub struct DHR12R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel2 12-bit right aligned data holding register"] +pub mod dhr12r2; +#[doc = "channel2 12-bit left aligned data holding register"] +pub struct DHR12L2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel2 12-bit left aligned data holding register"] +pub mod dhr12l2; +#[doc = "channel2 8-bit right-aligned data holding register"] +pub struct DHR8R2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel2 8-bit right-aligned data holding register"] +pub mod dhr8r2; +#[doc = "Dual DAC 12-bit right-aligned data holding register"] +pub struct DHR12RD { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Dual DAC 12-bit right-aligned data holding register"] +pub mod dhr12rd; +#[doc = "DUAL DAC 12-bit left aligned data holding register"] +pub struct DHR12LD { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DUAL DAC 12-bit left aligned data holding register"] +pub mod dhr12ld; +#[doc = "DUAL DAC 8-bit right aligned data holding register"] +pub struct DHR8RD { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DUAL DAC 8-bit right aligned data holding register"] +pub mod dhr8rd; +#[doc = "channel1 data output register"] +pub struct DOR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel1 data output register"] +pub mod dor1; +#[doc = "channel2 data output register"] +pub struct DOR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel2 data output register"] +pub mod dor2; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; diff --git a/src/dac/sr/mod.rs b/src/dac/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b1a215800e971ac88a302e245691b6c3cfd69ae --- /dev/null +++ b/src/dac/sr/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMAUDR2R { + bits: bool, +} +impl DMAUDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAUDR1R { + bits: bool, +} +impl DMAUDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DMAUDR2W<'a> { + w: &'a mut W, +} +impl<'a> _DMAUDR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAUDR1W<'a> { + w: &'a mut W, +} +impl<'a> _DMAUDR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 29 - DAC channel2 DMA underrun flag"] + #[inline] + pub fn dmaudr2(&self) -> DMAUDR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAUDR2R { bits } + } + #[doc = "Bit 13 - DAC channel1 DMA underrun flag"] + #[inline] + pub fn dmaudr1(&self) -> DMAUDR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAUDR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 29 - DAC channel2 DMA underrun flag"] + #[inline] + pub fn dmaudr2(&mut self) -> _DMAUDR2W { + _DMAUDR2W { w: self } + } + #[doc = "Bit 13 - DAC channel1 DMA underrun flag"] + #[inline] + pub fn dmaudr1(&mut self) -> _DMAUDR1W { + _DMAUDR1W { w: self } + } +} diff --git a/src/dac/swtrigr/mod.rs b/src/dac/swtrigr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aff587fb4a171356b5450852f0e94c99bbca6667 --- /dev/null +++ b/src/dac/swtrigr/mod.rs @@ -0,0 +1,85 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SWTRIGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _SWTRIG2W<'a> { + w: &'a mut W, +} +impl<'a> _SWTRIG2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWTRIG1W<'a> { + w: &'a mut W, +} +impl<'a> _SWTRIG1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - DAC channel2 software trigger"] + #[inline] + pub fn swtrig2(&mut self) -> _SWTRIG2W { + _SWTRIG2W { w: self } + } + #[doc = "Bit 0 - DAC channel1 software trigger"] + #[inline] + pub fn swtrig1(&mut self) -> _SWTRIG1W { + _SWTRIG1W { w: self } + } +} diff --git a/src/dbg/dbgmcu_apb1_fz/mod.rs b/src/dbg/dbgmcu_apb1_fz/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6a4f733bd6f55e35ec52965b8512f2e83c9a4f73 --- /dev/null +++ b/src/dbg/dbgmcu_apb1_fz/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DBGMCU_APB1_FZ { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM2_STOPR { + bits: bool, +} +impl DBG_TIM2_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM3_STOPR { + bits: bool, +} +impl DBG_TIM3_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM4_STOPR { + bits: bool, +} +impl DBG_TIM4_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM5_STOPR { + bits: bool, +} +impl DBG_TIM5_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_RTC_STOPR { + bits: bool, +} +impl DBG_RTC_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_WWDG_STOPR { + bits: bool, +} +impl DBG_WWDG_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_IWDEG_STOPR { + bits: bool, +} +impl DBG_IWDEG_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_I2C1_SMBUS_TIMEOUTR { + bits: bool, +} +impl DBG_I2C1_SMBUS_TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_I2C2_SMBUS_TIMEOUTR { + bits: bool, +} +impl DBG_I2C2_SMBUS_TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_I2C3SMBUS_TIMEOUTR { + bits: bool, +} +impl DBG_I2C3SMBUS_TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM2_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM2_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM3_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM3_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM4_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM4_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM5_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM5_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_RTC_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_RTC_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_WWDG_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_WWDG_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_IWDEG_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_IWDEG_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_I2C1_SMBUS_TIMEOUTW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_I2C1_SMBUS_TIMEOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_I2C2_SMBUS_TIMEOUTW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_I2C2_SMBUS_TIMEOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_I2C3SMBUS_TIMEOUTW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_I2C3SMBUS_TIMEOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - DBG_TIM2_STOP"] + #[inline] + pub fn dbg_tim2_stop(&self) -> DBG_TIM2_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM2_STOPR { bits } + } + #[doc = "Bit 1 - DBG_TIM3 _STOP"] + #[inline] + pub fn dbg_tim3_stop(&self) -> DBG_TIM3_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM3_STOPR { bits } + } + #[doc = "Bit 2 - DBG_TIM4_STOP"] + #[inline] + pub fn dbg_tim4_stop(&self) -> DBG_TIM4_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM4_STOPR { bits } + } + #[doc = "Bit 3 - DBG_TIM5_STOP"] + #[inline] + pub fn dbg_tim5_stop(&self) -> DBG_TIM5_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM5_STOPR { bits } + } + #[doc = "Bit 10 - RTC stopped when Core is halted"] + #[inline] + pub fn dbg_rtc_stop(&self) -> DBG_RTC_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_RTC_STOPR { bits } + } + #[doc = "Bit 11 - DBG_WWDG_STOP"] + #[inline] + pub fn dbg_wwdg_stop(&self) -> DBG_WWDG_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_WWDG_STOPR { bits } + } + #[doc = "Bit 12 - DBG_IWDEG_STOP"] + #[inline] + pub fn dbg_iwdeg_stop(&self) -> DBG_IWDEG_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_IWDEG_STOPR { bits } + } + #[doc = "Bit 21 - DBG_J2C1_SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c1_smbus_timeout(&self) -> DBG_I2C1_SMBUS_TIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_I2C1_SMBUS_TIMEOUTR { bits } + } + #[doc = "Bit 22 - DBG_J2C2_SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c2_smbus_timeout(&self) -> DBG_I2C2_SMBUS_TIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_I2C2_SMBUS_TIMEOUTR { bits } + } + #[doc = "Bit 23 - DBG_J2C3SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c3smbus_timeout(&self) -> DBG_I2C3SMBUS_TIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_I2C3SMBUS_TIMEOUTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - DBG_TIM2_STOP"] + #[inline] + pub fn dbg_tim2_stop(&mut self) -> _DBG_TIM2_STOPW { + _DBG_TIM2_STOPW { w: self } + } + #[doc = "Bit 1 - DBG_TIM3 _STOP"] + #[inline] + pub fn dbg_tim3_stop(&mut self) -> _DBG_TIM3_STOPW { + _DBG_TIM3_STOPW { w: self } + } + #[doc = "Bit 2 - DBG_TIM4_STOP"] + #[inline] + pub fn dbg_tim4_stop(&mut self) -> _DBG_TIM4_STOPW { + _DBG_TIM4_STOPW { w: self } + } + #[doc = "Bit 3 - DBG_TIM5_STOP"] + #[inline] + pub fn dbg_tim5_stop(&mut self) -> _DBG_TIM5_STOPW { + _DBG_TIM5_STOPW { w: self } + } + #[doc = "Bit 10 - RTC stopped when Core is halted"] + #[inline] + pub fn dbg_rtc_stop(&mut self) -> _DBG_RTC_STOPW { + _DBG_RTC_STOPW { w: self } + } + #[doc = "Bit 11 - DBG_WWDG_STOP"] + #[inline] + pub fn dbg_wwdg_stop(&mut self) -> _DBG_WWDG_STOPW { + _DBG_WWDG_STOPW { w: self } + } + #[doc = "Bit 12 - DBG_IWDEG_STOP"] + #[inline] + pub fn dbg_iwdeg_stop(&mut self) -> _DBG_IWDEG_STOPW { + _DBG_IWDEG_STOPW { w: self } + } + #[doc = "Bit 21 - DBG_J2C1_SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c1_smbus_timeout(&mut self) -> _DBG_I2C1_SMBUS_TIMEOUTW { + _DBG_I2C1_SMBUS_TIMEOUTW { w: self } + } + #[doc = "Bit 22 - DBG_J2C2_SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c2_smbus_timeout(&mut self) -> _DBG_I2C2_SMBUS_TIMEOUTW { + _DBG_I2C2_SMBUS_TIMEOUTW { w: self } + } + #[doc = "Bit 23 - DBG_J2C3SMBUS_TIMEOUT"] + #[inline] + pub fn dbg_i2c3smbus_timeout(&mut self) -> _DBG_I2C3SMBUS_TIMEOUTW { + _DBG_I2C3SMBUS_TIMEOUTW { w: self } + } +} diff --git a/src/dbg/dbgmcu_apb2_fz/mod.rs b/src/dbg/dbgmcu_apb2_fz/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7e80a77f8b289b983a0ffde4308a8c8c044566c8 --- /dev/null +++ b/src/dbg/dbgmcu_apb2_fz/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DBGMCU_APB2_FZ { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM1_STOPR { + bits: bool, +} +impl DBG_TIM1_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM9_STOPR { + bits: bool, +} +impl DBG_TIM9_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM10_STOPR { + bits: bool, +} +impl DBG_TIM10_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_TIM11_STOPR { + bits: bool, +} +impl DBG_TIM11_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM1_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM1_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM9_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM9_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM10_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM10_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_TIM11_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_TIM11_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM1 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim1_stop(&self) -> DBG_TIM1_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM1_STOPR { bits } + } + #[doc = "Bit 16 - TIM9 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim9_stop(&self) -> DBG_TIM9_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM9_STOPR { bits } + } + #[doc = "Bit 17 - TIM10 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim10_stop(&self) -> DBG_TIM10_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM10_STOPR { bits } + } + #[doc = "Bit 18 - TIM11 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim11_stop(&self) -> DBG_TIM11_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_TIM11_STOPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM1 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim1_stop(&mut self) -> _DBG_TIM1_STOPW { + _DBG_TIM1_STOPW { w: self } + } + #[doc = "Bit 16 - TIM9 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim9_stop(&mut self) -> _DBG_TIM9_STOPW { + _DBG_TIM9_STOPW { w: self } + } + #[doc = "Bit 17 - TIM10 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim10_stop(&mut self) -> _DBG_TIM10_STOPW { + _DBG_TIM10_STOPW { w: self } + } + #[doc = "Bit 18 - TIM11 counter stopped when core is halted"] + #[inline] + pub fn dbg_tim11_stop(&mut self) -> _DBG_TIM11_STOPW { + _DBG_TIM11_STOPW { w: self } + } +} diff --git a/src/dbg/dbgmcu_cr/mod.rs b/src/dbg/dbgmcu_cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6da92d5af475f123610dd7f0ca0c08a4854c6d96 --- /dev/null +++ b/src/dbg/dbgmcu_cr/mod.rs @@ -0,0 +1,341 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DBGMCU_CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBG_SLEEPR { + bits: bool, +} +impl DBG_SLEEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_STOPR { + bits: bool, +} +impl DBG_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBG_STANDBYR { + bits: bool, +} +impl DBG_STANDBYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRACE_IOENR { + bits: bool, +} +impl TRACE_IOENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRACE_MODER { + bits: u8, +} +impl TRACE_MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DBG_SLEEPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_SLEEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBG_STANDBYW<'a> { + w: &'a mut W, +} +impl<'a> _DBG_STANDBYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRACE_IOENW<'a> { + w: &'a mut W, +} +impl<'a> _TRACE_IOENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRACE_MODEW<'a> { + w: &'a mut W, +} +impl<'a> _TRACE_MODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - DBG_SLEEP"] + #[inline] + pub fn dbg_sleep(&self) -> DBG_SLEEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_SLEEPR { bits } + } + #[doc = "Bit 1 - DBG_STOP"] + #[inline] + pub fn dbg_stop(&self) -> DBG_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_STOPR { bits } + } + #[doc = "Bit 2 - DBG_STANDBY"] + #[inline] + pub fn dbg_standby(&self) -> DBG_STANDBYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBG_STANDBYR { bits } + } + #[doc = "Bit 5 - TRACE_IOEN"] + #[inline] + pub fn trace_ioen(&self) -> TRACE_IOENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TRACE_IOENR { bits } + } + #[doc = "Bits 6:7 - TRACE_MODE"] + #[inline] + pub fn trace_mode(&self) -> TRACE_MODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRACE_MODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - DBG_SLEEP"] + #[inline] + pub fn dbg_sleep(&mut self) -> _DBG_SLEEPW { + _DBG_SLEEPW { w: self } + } + #[doc = "Bit 1 - DBG_STOP"] + #[inline] + pub fn dbg_stop(&mut self) -> _DBG_STOPW { + _DBG_STOPW { w: self } + } + #[doc = "Bit 2 - DBG_STANDBY"] + #[inline] + pub fn dbg_standby(&mut self) -> _DBG_STANDBYW { + _DBG_STANDBYW { w: self } + } + #[doc = "Bit 5 - TRACE_IOEN"] + #[inline] + pub fn trace_ioen(&mut self) -> _TRACE_IOENW { + _TRACE_IOENW { w: self } + } + #[doc = "Bits 6:7 - TRACE_MODE"] + #[inline] + pub fn trace_mode(&mut self) -> _TRACE_MODEW { + _TRACE_MODEW { w: self } + } +} diff --git a/src/dbg/dbgmcu_idcode/mod.rs b/src/dbg/dbgmcu_idcode/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..524d1a13b6993559651ca9ef84f54b8fe74252b4 --- /dev/null +++ b/src/dbg/dbgmcu_idcode/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DBGMCU_IDCODE { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DEV_IDR { + bits: u16, +} +impl DEV_IDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct REV_IDR { + bits: u16, +} +impl REV_IDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - DEV_ID"] + #[inline] + pub fn dev_id(&self) -> DEV_IDR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DEV_IDR { bits } + } + #[doc = "Bits 16:31 - REV_ID"] + #[inline] + pub fn rev_id(&self) -> REV_IDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + REV_IDR { bits } + } +} diff --git a/src/dbg/mod.rs b/src/dbg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2ba00beed149262316951a25f2d30152c25e20d0 --- /dev/null +++ b/src/dbg/mod.rs @@ -0,0 +1,36 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - IDCODE"] + pub dbgmcu_idcode: DBGMCU_IDCODE, + #[doc = "0x04 - Control Register"] + pub dbgmcu_cr: DBGMCU_CR, + #[doc = "0x08 - Debug MCU APB1 Freeze registe"] + pub dbgmcu_apb1_fz: DBGMCU_APB1_FZ, + #[doc = "0x0c - Debug MCU APB2 Freeze registe"] + pub dbgmcu_apb2_fz: DBGMCU_APB2_FZ, +} +#[doc = "IDCODE"] +pub struct DBGMCU_IDCODE { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "IDCODE"] +pub mod dbgmcu_idcode; +#[doc = "Control Register"] +pub struct DBGMCU_CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control Register"] +pub mod dbgmcu_cr; +#[doc = "Debug MCU APB1 Freeze registe"] +pub struct DBGMCU_APB1_FZ { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Debug MCU APB1 Freeze registe"] +pub mod dbgmcu_apb1_fz; +#[doc = "Debug MCU APB2 Freeze registe"] +pub struct DBGMCU_APB2_FZ { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Debug MCU APB2 Freeze registe"] +pub mod dbgmcu_apb2_fz; diff --git a/src/dfsdm1/ch0awscdr/mod.rs b/src/dfsdm1/ch0awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9224f37f4e636fca17defd4cd69e641a894a27c6 --- /dev/null +++ b/src/dfsdm1/ch0awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH0AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch0cfgr1/mod.rs b/src/dfsdm1/ch0cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7aab289b7cc0e0baff44d6e3a29e39db367f7729 --- /dev/null +++ b/src/dfsdm1/ch0cfgr1/mod.rs @@ -0,0 +1,623 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH0CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DFSDMENR { + bits: bool, +} +impl DFSDMENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKOUTSRCR { + bits: bool, +} +impl CKOUTSRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKOUTDIVR { + bits: u8, +} +impl CKOUTDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DFSDMENW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDMENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKOUTSRCW<'a> { + w: &'a mut W, +} +impl<'a> _CKOUTSRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKOUTDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CKOUTDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - DFSDMEN"] + #[inline] + pub fn dfsdmen(&self) -> DFSDMENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDMENR { bits } + } + #[doc = "Bit 30 - CKOUTSRC"] + #[inline] + pub fn ckoutsrc(&self) -> CKOUTSRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKOUTSRCR { bits } + } + #[doc = "Bits 16:23 - CKOUTDIV"] + #[inline] + pub fn ckoutdiv(&self) -> CKOUTDIVR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKOUTDIVR { bits } + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - DFSDMEN"] + #[inline] + pub fn dfsdmen(&mut self) -> _DFSDMENW { + _DFSDMENW { w: self } + } + #[doc = "Bit 30 - CKOUTSRC"] + #[inline] + pub fn ckoutsrc(&mut self) -> _CKOUTSRCW { + _CKOUTSRCW { w: self } + } + #[doc = "Bits 16:23 - CKOUTDIV"] + #[inline] + pub fn ckoutdiv(&mut self) -> _CKOUTDIVW { + _CKOUTDIVW { w: self } + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch0cfgr2/mod.rs b/src/dfsdm1/ch0cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0ba372bd1379e122203aab51a2fa619775a0c7a2 --- /dev/null +++ b/src/dfsdm1/ch0cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH0CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch0datinr/mod.rs b/src/dfsdm1/ch0datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d5d46ed74daefbd028a468c1a6ed55a01ccd9f65 --- /dev/null +++ b/src/dfsdm1/ch0datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH0DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch0wdatr/mod.rs b/src/dfsdm1/ch0wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fa993b490489c1c35cfa2db9a8b3b5cd6f406b3c --- /dev/null +++ b/src/dfsdm1/ch0wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH0WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch1awscdr/mod.rs b/src/dfsdm1/ch1awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4fe3de3aad3603984bd7eccded971854525efed5 --- /dev/null +++ b/src/dfsdm1/ch1awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH1AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch1cfgr1/mod.rs b/src/dfsdm1/ch1cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..922bd531bc508eb6200d10c69a420535911e329a --- /dev/null +++ b/src/dfsdm1/ch1cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH1CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch1cfgr2/mod.rs b/src/dfsdm1/ch1cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f191c7821e606c0f1fa7c8ae6ac8ee13ae7f8f57 --- /dev/null +++ b/src/dfsdm1/ch1cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH1CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch1datinr/mod.rs b/src/dfsdm1/ch1datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d92b7539dcc147a04a31b2eeb9b75769fb144613 --- /dev/null +++ b/src/dfsdm1/ch1datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH1DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch1wdatr/mod.rs b/src/dfsdm1/ch1wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ebc8aca41d14db2e378d3d888764ce82c9219e3d --- /dev/null +++ b/src/dfsdm1/ch1wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH1WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch2awscdr/mod.rs b/src/dfsdm1/ch2awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a2e7153687290e7a5582f37f70fb60f89fbf9460 --- /dev/null +++ b/src/dfsdm1/ch2awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH2AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch2cfgr1/mod.rs b/src/dfsdm1/ch2cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b018cfe027783abb004adebb86b15b4c45b3680 --- /dev/null +++ b/src/dfsdm1/ch2cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH2CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch2cfgr2/mod.rs b/src/dfsdm1/ch2cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b4f867dcf9c1758aab7e8383b4485f0dff3bec2 --- /dev/null +++ b/src/dfsdm1/ch2cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH2CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch2datinr/mod.rs b/src/dfsdm1/ch2datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1f6169cd4ea01a95633a4c7849e8397a434303b3 --- /dev/null +++ b/src/dfsdm1/ch2datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH2DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch2wdatr/mod.rs b/src/dfsdm1/ch2wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..801b55e0b9a674ce20880756b79f77689c7cfe94 --- /dev/null +++ b/src/dfsdm1/ch2wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH2WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch3awscdr/mod.rs b/src/dfsdm1/ch3awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aa933975f2d8ed6250893318590d44ab6e206bca --- /dev/null +++ b/src/dfsdm1/ch3awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH3AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch3cfgr1/mod.rs b/src/dfsdm1/ch3cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..571b04df629ba539b8f7f52872f46312a6d18732 --- /dev/null +++ b/src/dfsdm1/ch3cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH3CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch3cfgr2/mod.rs b/src/dfsdm1/ch3cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5f6110425d68bfbe67af81ca943624284c000dc7 --- /dev/null +++ b/src/dfsdm1/ch3cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH3CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch3datinr/mod.rs b/src/dfsdm1/ch3datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7daa3a8dee5959a1c56be1d95dd29e3abd2cb484 --- /dev/null +++ b/src/dfsdm1/ch3datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH3DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch3wdatr/mod.rs b/src/dfsdm1/ch3wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5569338ed3a3cd22b1373d755112738242ab3f6c --- /dev/null +++ b/src/dfsdm1/ch3wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH3WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch4awscdr/mod.rs b/src/dfsdm1/ch4awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9cec98f06333a49fc846d86adf9602efc858bd39 --- /dev/null +++ b/src/dfsdm1/ch4awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH4AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch4cfgr1/mod.rs b/src/dfsdm1/ch4cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a34ae46bf6f04ce3e99cbb79162a51de5409ab42 --- /dev/null +++ b/src/dfsdm1/ch4cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH4CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch4cfgr2/mod.rs b/src/dfsdm1/ch4cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d6adb3887f573ee9c6cec90702b410e12932ce72 --- /dev/null +++ b/src/dfsdm1/ch4cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH4CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch4datinr/mod.rs b/src/dfsdm1/ch4datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4f06ecf6df324f7705cca2d08aac12c9a1f2a76e --- /dev/null +++ b/src/dfsdm1/ch4datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH4DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch4wdatr/mod.rs b/src/dfsdm1/ch4wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3e483b0dbe640cf4320c41a069892e77b74a4aae --- /dev/null +++ b/src/dfsdm1/ch4wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH4WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch5awscdr/mod.rs b/src/dfsdm1/ch5awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..716c5ade4f53945d1d07b15d2cf26ee1e268abbb --- /dev/null +++ b/src/dfsdm1/ch5awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH5AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch5cfgr1/mod.rs b/src/dfsdm1/ch5cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d8e32fa5101ff90a10e16275edef324544a3117 --- /dev/null +++ b/src/dfsdm1/ch5cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH5CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch5cfgr2/mod.rs b/src/dfsdm1/ch5cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..03dbdf6103c8f57ce4a920ef3aea9f022385f9ad --- /dev/null +++ b/src/dfsdm1/ch5cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH5CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch5datinr/mod.rs b/src/dfsdm1/ch5datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cedcc8c3bf0de036aa1c9730fa032ce9e374472c --- /dev/null +++ b/src/dfsdm1/ch5datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH5DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch5wdatr/mod.rs b/src/dfsdm1/ch5wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..85c19448ded770137d1c51088dff91ab8863d678 --- /dev/null +++ b/src/dfsdm1/ch5wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH5WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch6awscdr/mod.rs b/src/dfsdm1/ch6awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3579e012cf96a0e51125bf962248d40a9503eed8 --- /dev/null +++ b/src/dfsdm1/ch6awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH6AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch6cfgr1/mod.rs b/src/dfsdm1/ch6cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..790c9df3654fa929704a41b4878dab44c5a26715 --- /dev/null +++ b/src/dfsdm1/ch6cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH6CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch6cfgr2/mod.rs b/src/dfsdm1/ch6cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c37549a74e1b773cd90f66d07d5c43bc68b9f978 --- /dev/null +++ b/src/dfsdm1/ch6cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH6CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch6datinr/mod.rs b/src/dfsdm1/ch6datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9fbe1e5f221566e845e31585b07077f20c050d88 --- /dev/null +++ b/src/dfsdm1/ch6datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH6DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch6wdatr/mod.rs b/src/dfsdm1/ch6wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..76f2024b61c3240fe5b974171b1aa07f64f25330 --- /dev/null +++ b/src/dfsdm1/ch6wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH6WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/ch7awscdr/mod.rs b/src/dfsdm1/ch7awscdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..51a3c375ff6b35f8ef2b5fd47f9f8341b2c5ce0c --- /dev/null +++ b/src/dfsdm1/ch7awscdr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH7AWSCDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFORDR { + bits: u8, +} +impl AWFORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWFOSRR { + bits: u8, +} +impl AWFOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKSCDR { + bits: u8, +} +impl BKSCDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCDTR { + bits: u8, +} +impl SCDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWFORDW<'a> { + w: &'a mut W, +} +impl<'a> _AWFORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWFOSRW<'a> { + w: &'a mut W, +} +impl<'a> _AWFOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKSCDW<'a> { + w: &'a mut W, +} +impl<'a> _BKSCDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDTW<'a> { + w: &'a mut W, +} +impl<'a> _SCDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&self) -> AWFORDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFORDR { bits } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&self) -> AWFOSRR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWFOSRR { bits } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&self) -> BKSCDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKSCDR { bits } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&self) -> SCDTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 22:23 - AWFORD"] + #[inline] + pub fn awford(&mut self) -> _AWFORDW { + _AWFORDW { w: self } + } + #[doc = "Bits 16:20 - AWFOSR"] + #[inline] + pub fn awfosr(&mut self) -> _AWFOSRW { + _AWFOSRW { w: self } + } + #[doc = "Bits 12:15 - BKSCD"] + #[inline] + pub fn bkscd(&mut self) -> _BKSCDW { + _BKSCDW { w: self } + } + #[doc = "Bits 0:7 - SCDT"] + #[inline] + pub fn scdt(&mut self) -> _SCDTW { + _SCDTW { w: self } + } +} diff --git a/src/dfsdm1/ch7cfgr1/mod.rs b/src/dfsdm1/ch7cfgr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cb5fa442048cf2cb6193ba21c4ce38c0322df46c --- /dev/null +++ b/src/dfsdm1/ch7cfgr1/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH7CFGR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATPACKR { + bits: u8, +} +impl DATPACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATMPXR { + bits: u8, +} +impl DATMPXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHINSELR { + bits: bool, +} +impl CHINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENR { + bits: bool, +} +impl CHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CKABENR { + bits: bool, +} +impl CKABENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDENR { + bits: bool, +} +impl SCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPICKSELR { + bits: u8, +} +impl SPICKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SITPR { + bits: u8, +} +impl SITPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATPACKW<'a> { + w: &'a mut W, +} +impl<'a> _DATPACKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATMPXW<'a> { + w: &'a mut W, +} +impl<'a> _DATMPXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHINSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENW<'a> { + w: &'a mut W, +} +impl<'a> _CHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABENW<'a> { + w: &'a mut W, +} +impl<'a> _CKABENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDENW<'a> { + w: &'a mut W, +} +impl<'a> _SCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPICKSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPICKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SITPW<'a> { + w: &'a mut W, +} +impl<'a> _SITPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&self) -> DATPACKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATPACKR { bits } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&self) -> DATMPXR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATMPXR { bits } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&self) -> CHINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHINSELR { bits } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&self) -> CHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENR { bits } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&self) -> CKABENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABENR { bits } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&self) -> SCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDENR { bits } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&self) -> SPICKSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SPICKSELR { bits } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&self) -> SITPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SITPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - DATPACK"] + #[inline] + pub fn datpack(&mut self) -> _DATPACKW { + _DATPACKW { w: self } + } + #[doc = "Bits 12:13 - DATMPX"] + #[inline] + pub fn datmpx(&mut self) -> _DATMPXW { + _DATMPXW { w: self } + } + #[doc = "Bit 8 - CHINSEL"] + #[inline] + pub fn chinsel(&mut self) -> _CHINSELW { + _CHINSELW { w: self } + } + #[doc = "Bit 7 - CHEN"] + #[inline] + pub fn chen(&mut self) -> _CHENW { + _CHENW { w: self } + } + #[doc = "Bit 6 - CKABEN"] + #[inline] + pub fn ckaben(&mut self) -> _CKABENW { + _CKABENW { w: self } + } + #[doc = "Bit 5 - SCDEN"] + #[inline] + pub fn scden(&mut self) -> _SCDENW { + _SCDENW { w: self } + } + #[doc = "Bits 2:3 - SPICKSEL"] + #[inline] + pub fn spicksel(&mut self) -> _SPICKSELW { + _SPICKSELW { w: self } + } + #[doc = "Bits 0:1 - SITP"] + #[inline] + pub fn sitp(&mut self) -> _SITPW { + _SITPW { w: self } + } +} diff --git a/src/dfsdm1/ch7cfgr2/mod.rs b/src/dfsdm1/ch7cfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6899abea4f15383dcd3b3147537ff59f93fdd24f --- /dev/null +++ b/src/dfsdm1/ch7cfgr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH7CFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OFFSETR { + bits: u32, +} +impl OFFSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTRBSR { + bits: u8, +} +impl DTRBSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OFFSETW<'a> { + w: &'a mut W, +} +impl<'a> _OFFSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTRBSW<'a> { + w: &'a mut W, +} +impl<'a> _DTRBSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&self) -> OFFSETR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + OFFSETR { bits } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&self) -> DTRBSR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTRBSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - OFFSET"] + #[inline] + pub fn offset(&mut self) -> _OFFSETW { + _OFFSETW { w: self } + } + #[doc = "Bits 3:7 - DTRBS"] + #[inline] + pub fn dtrbs(&mut self) -> _DTRBSW { + _DTRBSW { w: self } + } +} diff --git a/src/dfsdm1/ch7datinr/mod.rs b/src/dfsdm1/ch7datinr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7a08dfb162a706570b91db72b74c1e4bb8672fd --- /dev/null +++ b/src/dfsdm1/ch7datinr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH7DATINR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INDAT1R { + bits: u16, +} +impl INDAT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INDAT0R { + bits: u16, +} +impl INDAT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INDAT1W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INDAT0W<'a> { + w: &'a mut W, +} +impl<'a> _INDAT0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&self) -> INDAT1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT1R { bits } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&self) -> INDAT0R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INDAT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - INDAT1"] + #[inline] + pub fn indat1(&mut self) -> _INDAT1W { + _INDAT1W { w: self } + } + #[doc = "Bits 0:15 - INDAT0"] + #[inline] + pub fn indat0(&mut self) -> _INDAT0W { + _INDAT0W { w: self } + } +} diff --git a/src/dfsdm1/ch7wdatr/mod.rs b/src/dfsdm1/ch7wdatr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0b941ebccad598301674e87bfbed2460834aea69 --- /dev/null +++ b/src/dfsdm1/ch7wdatr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CH7WDATR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDATAR { + bits: u16, +} +impl WDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDATAW<'a> { + w: &'a mut W, +} +impl<'a> _WDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&self) -> WDATAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - WDATA"] + #[inline] + pub fn wdata(&mut self) -> _WDATAW { + _WDATAW { w: self } + } +} diff --git a/src/dfsdm1/flt0awcfr/mod.rs b/src/dfsdm1/flt0awcfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ff92c87de9608a61adbb49f4b81b564f551cc5fd --- /dev/null +++ b/src/dfsdm1/flt0awcfr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0AWCFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRAWHTFR { + bits: u8, +} +impl CLRAWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRAWLTFR { + bits: u8, +} +impl CLRAWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CLRAWHTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWHTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRAWLTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWLTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&self) -> CLRAWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWHTFR { bits } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&self) -> CLRAWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWLTFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&mut self) -> _CLRAWHTFW { + _CLRAWHTFW { w: self } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&mut self) -> _CLRAWLTFW { + _CLRAWLTFW { w: self } + } +} diff --git a/src/dfsdm1/flt0awhtr/mod.rs b/src/dfsdm1/flt0awhtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4706139d6bb7615ace16b048dbeffb07cb7d89f9 --- /dev/null +++ b/src/dfsdm1/flt0awhtr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0AWHTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWHTR { + bits: u32, +} +impl AWHTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWHR { + bits: u8, +} +impl BKAWHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWHTW<'a> { + w: &'a mut W, +} +impl<'a> _AWHTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWHW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&self) -> AWHTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWHTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&self) -> BKAWHR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&mut self) -> _AWHTW { + _AWHTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&mut self) -> _BKAWHW { + _BKAWHW { w: self } + } +} diff --git a/src/dfsdm1/flt0awltr/mod.rs b/src/dfsdm1/flt0awltr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..70581fa258c7fde06ec5935837613dd2458862eb --- /dev/null +++ b/src/dfsdm1/flt0awltr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0AWLTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWLTR { + bits: u32, +} +impl AWLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWLR { + bits: u8, +} +impl BKAWLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWLTW<'a> { + w: &'a mut W, +} +impl<'a> _AWLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWLW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&self) -> AWLTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWLTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&self) -> BKAWLR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&mut self) -> _AWLTW { + _AWLTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&mut self) -> _BKAWLW { + _BKAWLW { w: self } + } +} diff --git a/src/dfsdm1/flt0awsr/mod.rs b/src/dfsdm1/flt0awsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..baefa81d33c84fa31d89efd96040611534c79b0c --- /dev/null +++ b/src/dfsdm1/flt0awsr/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0AWSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct AWHTFR { + bits: u8, +} +impl AWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWLTFR { + bits: u8, +} +impl AWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Analog watchdog high threshold flag"] + #[inline] + pub fn awhtf(&self) -> AWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWHTFR { bits } + } + #[doc = "Bits 0:7 - Analog watchdog low threshold flag"] + #[inline] + pub fn awltf(&self) -> AWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWLTFR { bits } + } +} diff --git a/src/dfsdm1/flt0cnvtimr/mod.rs b/src/dfsdm1/flt0cnvtimr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8377a23cba3fffc82d45e3acbe49ffb4d6b2615 --- /dev/null +++ b/src/dfsdm1/flt0cnvtimr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0CNVTIMR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CNVCNTR { + bits: u32, +} +impl CNVCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN"] + #[inline] + pub fn cnvcnt(&self) -> CNVCNTR { + let bits = { + const MASK: u32 = 268435455; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CNVCNTR { bits } + } +} diff --git a/src/dfsdm1/flt0cr1/mod.rs b/src/dfsdm1/flt0cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f03435f90456c832287f586812d5cb444a0fd9cf --- /dev/null +++ b/src/dfsdm1/flt0cr1/mod.rs @@ -0,0 +1,836 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFSELR { + bits: bool, +} +impl AWFSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FASTR { + bits: bool, +} +impl FASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCHR { + bits: u8, +} +impl RCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RDMAENR { + bits: bool, +} +impl RDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSYNCR { + bits: bool, +} +impl RSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCONTR { + bits: bool, +} +impl RCONTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSWSTARTR { + bits: bool, +} +impl RSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEXTENR { + bits: u8, +} +impl JEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JEXTSELR { + bits: u8, +} +impl JEXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDMAENR { + bits: bool, +} +impl JDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSCANR { + bits: bool, +} +impl JSCANR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSYNCR { + bits: bool, +} +impl JSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSWSTARTR { + bits: bool, +} +impl JSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFENR { + bits: bool, +} +impl DFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWFSELW<'a> { + w: &'a mut W, +} +impl<'a> _AWFSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FASTW<'a> { + w: &'a mut W, +} +impl<'a> _FASTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCHW<'a> { + w: &'a mut W, +} +impl<'a> _RCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _RSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCONTW<'a> { + w: &'a mut W, +} +impl<'a> _RCONTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _RSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _JDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSCANW<'a> { + w: &'a mut W, +} +impl<'a> _JSCANW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _JSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _JSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFENW<'a> { + w: &'a mut W, +} +impl<'a> _DFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&self) -> AWFSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWFSELR { bits } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&self) -> FASTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FASTR { bits } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&self) -> RCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RCHR { bits } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&self) -> RDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RDMAENR { bits } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&self) -> RSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSYNCR { bits } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&self) -> RCONTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCONTR { bits } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&self) -> RSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSWSTARTR { bits } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&self) -> JEXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTENR { bits } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&self) -> JEXTSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTSELR { bits } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&self) -> JDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JDMAENR { bits } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&self) -> JSCANR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSCANR { bits } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&self) -> JSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSYNCR { bits } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&self) -> JSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSWSTARTR { bits } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&self) -> DFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&mut self) -> _AWFSELW { + _AWFSELW { w: self } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&mut self) -> _FASTW { + _FASTW { w: self } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&mut self) -> _RCHW { + _RCHW { w: self } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&mut self) -> _RDMAENW { + _RDMAENW { w: self } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&mut self) -> _RSYNCW { + _RSYNCW { w: self } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&mut self) -> _RCONTW { + _RCONTW { w: self } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&mut self) -> _RSWSTARTW { + _RSWSTARTW { w: self } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&mut self) -> _JEXTENW { + _JEXTENW { w: self } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&mut self) -> _JEXTSELW { + _JEXTSELW { w: self } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&mut self) -> _JDMAENW { + _JDMAENW { w: self } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&mut self) -> _JSCANW { + _JSCANW { w: self } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&mut self) -> _JSYNCW { + _JSYNCW { w: self } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&mut self) -> _JSWSTARTW { + _JSWSTARTW { w: self } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&mut self) -> _DFENW { + _DFENW { w: self } + } +} diff --git a/src/dfsdm1/flt0cr2/mod.rs b/src/dfsdm1/flt0cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5f19c7227ae997b7afbc648009192b5aa9470852 --- /dev/null +++ b/src/dfsdm1/flt0cr2/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWDCHR { + bits: u8, +} +impl AWDCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXCHR { + bits: u8, +} +impl EXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABIER { + bits: bool, +} +impl CKABIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDIER { + bits: bool, +} +impl SCDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDIER { + bits: bool, +} +impl AWDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRIER { + bits: bool, +} +impl ROVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRIER { + bits: bool, +} +impl JOVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCIER { + bits: bool, +} +impl REOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCIER { + bits: bool, +} +impl JEOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWDCHW<'a> { + w: &'a mut W, +} +impl<'a> _AWDCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXCHW<'a> { + w: &'a mut W, +} +impl<'a> _EXCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABIEW<'a> { + w: &'a mut W, +} +impl<'a> _CKABIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDIEW<'a> { + w: &'a mut W, +} +impl<'a> _SCDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDIEW<'a> { + w: &'a mut W, +} +impl<'a> _AWDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ROVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ROVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JOVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _JOVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _REOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&self) -> AWDCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWDCHR { bits } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&self) -> EXCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXCHR { bits } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&self) -> CKABIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABIER { bits } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&self) -> SCDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDIER { bits } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&self) -> AWDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDIER { bits } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&self) -> ROVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRIER { bits } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&self) -> JOVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRIER { bits } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&self) -> REOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCIER { bits } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&self) -> JEOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&mut self) -> _AWDCHW { + _AWDCHW { w: self } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&mut self) -> _EXCHW { + _EXCHW { w: self } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&mut self) -> _CKABIEW { + _CKABIEW { w: self } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&mut self) -> _SCDIEW { + _SCDIEW { w: self } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&mut self) -> _AWDIEW { + _AWDIEW { w: self } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&mut self) -> _ROVRIEW { + _ROVRIEW { w: self } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&mut self) -> _JOVRIEW { + _JOVRIEW { w: self } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&mut self) -> _REOCIEW { + _REOCIEW { w: self } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&mut self) -> _JEOCIEW { + _JEOCIEW { w: self } + } +} diff --git a/src/dfsdm1/flt0exmax/mod.rs b/src/dfsdm1/flt0exmax/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9117a9d2573fc2bca74ff54c670ded9d3237d336 --- /dev/null +++ b/src/dfsdm1/flt0exmax/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0EXMAX { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMAXR { + bits: u32, +} +impl EXMAXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMAXCHR { + bits: u8, +} +impl EXMAXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Extremes detector maximum value"] + #[inline] + pub fn exmax(&self) -> EXMAXR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMAXR { bits } + } + #[doc = "Bits 0:2 - Extremes detector maximum data channel"] + #[inline] + pub fn exmaxch(&self) -> EXMAXCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMAXCHR { bits } + } +} diff --git a/src/dfsdm1/flt0exmin/mod.rs b/src/dfsdm1/flt0exmin/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8977558154668a46a31a28eb1bc9353542c55445 --- /dev/null +++ b/src/dfsdm1/flt0exmin/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0EXMIN { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMINR { + bits: u32, +} +impl EXMINR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMINCHR { + bits: u8, +} +impl EXMINCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - EXMIN"] + #[inline] + pub fn exmin(&self) -> EXMINR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMINR { bits } + } + #[doc = "Bits 0:2 - Extremes detector minimum data channel"] + #[inline] + pub fn exminch(&self) -> EXMINCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMINCHR { bits } + } +} diff --git a/src/dfsdm1/flt0fcr/mod.rs b/src/dfsdm1/flt0fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..40342afcb65abb7eb08528e549cbde03f57c4de9 --- /dev/null +++ b/src/dfsdm1/flt0fcr/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FORDR { + bits: u8, +} +impl FORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FOSRR { + bits: u16, +} +impl FOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOSRR { + bits: u8, +} +impl IOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FORDW<'a> { + w: &'a mut W, +} +impl<'a> _FORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOSRW<'a> { + w: &'a mut W, +} +impl<'a> _FOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOSRW<'a> { + w: &'a mut W, +} +impl<'a> _IOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&self) -> FORDR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FORDR { bits } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&self) -> FOSRR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FOSRR { bits } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&self) -> IOSRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOSRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&mut self) -> _FORDW { + _FORDW { w: self } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&mut self) -> _FOSRW { + _FOSRW { w: self } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&mut self) -> _IOSRW { + _IOSRW { w: self } + } +} diff --git a/src/dfsdm1/flt0icr/mod.rs b/src/dfsdm1/flt0icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a1256c0e361d251045f863ee3a182139bc7edd62 --- /dev/null +++ b/src/dfsdm1/flt0icr/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0ICR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRSCDFR { + bits: u8, +} +impl CLRSCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRCKABFR { + bits: u8, +} +impl CLRCKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRROVRFR { + bits: bool, +} +impl CLRROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLRJOVRFR { + bits: bool, +} +impl CLRJOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CLRSCDFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRSCDFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRCKABFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRCKABFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRROVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRROVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRJOVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRJOVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&self) -> CLRSCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRSCDFR { bits } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&self) -> CLRCKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRCKABFR { bits } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&self) -> CLRROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRROVRFR { bits } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&self) -> CLRJOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRJOVRFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&mut self) -> _CLRSCDFW { + _CLRSCDFW { w: self } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&mut self) -> _CLRCKABFW { + _CLRCKABFW { w: self } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&mut self) -> _CLRROVRFW { + _CLRROVRFW { w: self } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&mut self) -> _CLRJOVRFW { + _CLRJOVRFW { w: self } + } +} diff --git a/src/dfsdm1/flt0isr/mod.rs b/src/dfsdm1/flt0isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..99f4f93c00f03fbf24b20ffa8363607d6112bf97 --- /dev/null +++ b/src/dfsdm1/flt0isr/mod.rs @@ -0,0 +1,279 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0ISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SCDFR { + bits: u8, +} +impl SCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABFR { + bits: u8, +} +impl CKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RCIPR { + bits: bool, +} +impl RCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JCIPR { + bits: bool, +} +impl JCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDFR { + bits: bool, +} +impl AWDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRFR { + bits: bool, +} +impl ROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRFR { + bits: bool, +} +impl JOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCFR { + bits: bool, +} +impl REOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCFR { + bits: bool, +} +impl JEOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - short-circuit detector flag"] + #[inline] + pub fn scdf(&self) -> SCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDFR { bits } + } + #[doc = "Bits 16:23 - Clock absence flag"] + #[inline] + pub fn ckabf(&self) -> CKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKABFR { bits } + } + #[doc = "Bit 14 - Regular conversion in progress status"] + #[inline] + pub fn rcip(&self) -> RCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCIPR { bits } + } + #[doc = "Bit 13 - Injected conversion in progress status"] + #[inline] + pub fn jcip(&self) -> JCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JCIPR { bits } + } + #[doc = "Bit 4 - Analog watchdog"] + #[inline] + pub fn awdf(&self) -> AWDFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDFR { bits } + } + #[doc = "Bit 3 - Regular conversion overrun flag"] + #[inline] + pub fn rovrf(&self) -> ROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRFR { bits } + } + #[doc = "Bit 2 - Injected conversion overrun flag"] + #[inline] + pub fn jovrf(&self) -> JOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRFR { bits } + } + #[doc = "Bit 1 - End of regular conversion flag"] + #[inline] + pub fn reocf(&self) -> REOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCFR { bits } + } + #[doc = "Bit 0 - End of injected conversion flag"] + #[inline] + pub fn jeocf(&self) -> JEOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCFR { bits } + } +} diff --git a/src/dfsdm1/flt0jchgr/mod.rs b/src/dfsdm1/flt0jchgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..25b3647a8bba823f2ca16a846ade24ab9c92559f --- /dev/null +++ b/src/dfsdm1/flt0jchgr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT0JCHGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JCHGR { + bits: u8, +} +impl JCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JCHGW<'a> { + w: &'a mut W, +} +impl<'a> _JCHGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&self) -> JCHGR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JCHGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&mut self) -> _JCHGW { + _JCHGW { w: self } + } +} diff --git a/src/dfsdm1/flt0jdatar/mod.rs b/src/dfsdm1/flt0jdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..138ea76f4c5199888edc3d9ca7ab55b1d0946422 --- /dev/null +++ b/src/dfsdm1/flt0jdatar/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0JDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u32, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDATACHR { + bits: u8, +} +impl JDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Injected group conversion data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + JDATAR { bits } + } + #[doc = "Bits 0:2 - Injected channel most recently converted"] + #[inline] + pub fn jdatach(&self) -> JDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt0rdatar/mod.rs b/src/dfsdm1/flt0rdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4f232a23c207c0a1f066c89ec2b2fd60290db1b6 --- /dev/null +++ b/src/dfsdm1/flt0rdatar/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT0RDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RDATAR { + bits: u32, +} +impl RDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RPENDR { + bits: bool, +} +impl RPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDATACHR { + bits: u8, +} +impl RDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Regular channel conversion data"] + #[inline] + pub fn rdata(&self) -> RDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + RDATAR { bits } + } + #[doc = "Bit 4 - Regular channel pending data"] + #[inline] + pub fn rpend(&self) -> RPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RPENDR { bits } + } + #[doc = "Bits 0:2 - Regular channel most recently converted"] + #[inline] + pub fn rdatach(&self) -> RDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt1awcfr/mod.rs b/src/dfsdm1/flt1awcfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b14dd5ffca1e563b99cb97d1e3bacb481a961ef5 --- /dev/null +++ b/src/dfsdm1/flt1awcfr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1AWCFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRAWHTFR { + bits: u8, +} +impl CLRAWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRAWLTFR { + bits: u8, +} +impl CLRAWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CLRAWHTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWHTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRAWLTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWLTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&self) -> CLRAWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWHTFR { bits } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&self) -> CLRAWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWLTFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&mut self) -> _CLRAWHTFW { + _CLRAWHTFW { w: self } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&mut self) -> _CLRAWLTFW { + _CLRAWLTFW { w: self } + } +} diff --git a/src/dfsdm1/flt1awhtr/mod.rs b/src/dfsdm1/flt1awhtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ca9df8365e10adc7f5221ae277d52360b2eeb7d8 --- /dev/null +++ b/src/dfsdm1/flt1awhtr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1AWHTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWHTR { + bits: u32, +} +impl AWHTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWHR { + bits: u8, +} +impl BKAWHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWHTW<'a> { + w: &'a mut W, +} +impl<'a> _AWHTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWHW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&self) -> AWHTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWHTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&self) -> BKAWHR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&mut self) -> _AWHTW { + _AWHTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&mut self) -> _BKAWHW { + _BKAWHW { w: self } + } +} diff --git a/src/dfsdm1/flt1awltr/mod.rs b/src/dfsdm1/flt1awltr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ff005306bbe18ac5950965439bd770709329502b --- /dev/null +++ b/src/dfsdm1/flt1awltr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1AWLTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWLTR { + bits: u32, +} +impl AWLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWLR { + bits: u8, +} +impl BKAWLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWLTW<'a> { + w: &'a mut W, +} +impl<'a> _AWLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWLW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&self) -> AWLTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWLTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&self) -> BKAWLR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&mut self) -> _AWLTW { + _AWLTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&mut self) -> _BKAWLW { + _BKAWLW { w: self } + } +} diff --git a/src/dfsdm1/flt1awsr/mod.rs b/src/dfsdm1/flt1awsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bed209ae5942f0d21cf3eddf5696f296250bc8ca --- /dev/null +++ b/src/dfsdm1/flt1awsr/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1AWSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct AWHTFR { + bits: u8, +} +impl AWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWLTFR { + bits: u8, +} +impl AWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Analog watchdog high threshold flag"] + #[inline] + pub fn awhtf(&self) -> AWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWHTFR { bits } + } + #[doc = "Bits 0:7 - Analog watchdog low threshold flag"] + #[inline] + pub fn awltf(&self) -> AWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWLTFR { bits } + } +} diff --git a/src/dfsdm1/flt1cnvtimr/mod.rs b/src/dfsdm1/flt1cnvtimr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1eb42d10924c9fb21f47d2190d9d2f9f7fe44197 --- /dev/null +++ b/src/dfsdm1/flt1cnvtimr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1CNVTIMR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CNVCNTR { + bits: u32, +} +impl CNVCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN"] + #[inline] + pub fn cnvcnt(&self) -> CNVCNTR { + let bits = { + const MASK: u32 = 268435455; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CNVCNTR { bits } + } +} diff --git a/src/dfsdm1/flt1cr1/mod.rs b/src/dfsdm1/flt1cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2f9e19e4f91b2a3fc84ca8e9ed67bbaf1f572517 --- /dev/null +++ b/src/dfsdm1/flt1cr1/mod.rs @@ -0,0 +1,836 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFSELR { + bits: bool, +} +impl AWFSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FASTR { + bits: bool, +} +impl FASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCHR { + bits: u8, +} +impl RCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RDMAENR { + bits: bool, +} +impl RDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSYNCR { + bits: bool, +} +impl RSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCONTR { + bits: bool, +} +impl RCONTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSWSTARTR { + bits: bool, +} +impl RSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEXTENR { + bits: u8, +} +impl JEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JEXTSELR { + bits: u8, +} +impl JEXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDMAENR { + bits: bool, +} +impl JDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSCANR { + bits: bool, +} +impl JSCANR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSYNCR { + bits: bool, +} +impl JSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSWSTARTR { + bits: bool, +} +impl JSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFENR { + bits: bool, +} +impl DFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWFSELW<'a> { + w: &'a mut W, +} +impl<'a> _AWFSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FASTW<'a> { + w: &'a mut W, +} +impl<'a> _FASTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCHW<'a> { + w: &'a mut W, +} +impl<'a> _RCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _RSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCONTW<'a> { + w: &'a mut W, +} +impl<'a> _RCONTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _RSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _JDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSCANW<'a> { + w: &'a mut W, +} +impl<'a> _JSCANW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _JSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _JSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFENW<'a> { + w: &'a mut W, +} +impl<'a> _DFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&self) -> AWFSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWFSELR { bits } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&self) -> FASTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FASTR { bits } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&self) -> RCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RCHR { bits } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&self) -> RDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RDMAENR { bits } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&self) -> RSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSYNCR { bits } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&self) -> RCONTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCONTR { bits } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&self) -> RSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSWSTARTR { bits } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&self) -> JEXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTENR { bits } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&self) -> JEXTSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTSELR { bits } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&self) -> JDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JDMAENR { bits } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&self) -> JSCANR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSCANR { bits } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&self) -> JSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSYNCR { bits } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&self) -> JSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSWSTARTR { bits } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&self) -> DFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&mut self) -> _AWFSELW { + _AWFSELW { w: self } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&mut self) -> _FASTW { + _FASTW { w: self } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&mut self) -> _RCHW { + _RCHW { w: self } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&mut self) -> _RDMAENW { + _RDMAENW { w: self } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&mut self) -> _RSYNCW { + _RSYNCW { w: self } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&mut self) -> _RCONTW { + _RCONTW { w: self } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&mut self) -> _RSWSTARTW { + _RSWSTARTW { w: self } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&mut self) -> _JEXTENW { + _JEXTENW { w: self } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&mut self) -> _JEXTSELW { + _JEXTSELW { w: self } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&mut self) -> _JDMAENW { + _JDMAENW { w: self } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&mut self) -> _JSCANW { + _JSCANW { w: self } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&mut self) -> _JSYNCW { + _JSYNCW { w: self } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&mut self) -> _JSWSTARTW { + _JSWSTARTW { w: self } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&mut self) -> _DFENW { + _DFENW { w: self } + } +} diff --git a/src/dfsdm1/flt1cr2/mod.rs b/src/dfsdm1/flt1cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0208250beae4dc8abde4f434a98295ddc7348863 --- /dev/null +++ b/src/dfsdm1/flt1cr2/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWDCHR { + bits: u8, +} +impl AWDCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXCHR { + bits: u8, +} +impl EXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABIER { + bits: bool, +} +impl CKABIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDIER { + bits: bool, +} +impl SCDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDIER { + bits: bool, +} +impl AWDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRIER { + bits: bool, +} +impl ROVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRIER { + bits: bool, +} +impl JOVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCIER { + bits: bool, +} +impl REOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCIER { + bits: bool, +} +impl JEOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWDCHW<'a> { + w: &'a mut W, +} +impl<'a> _AWDCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXCHW<'a> { + w: &'a mut W, +} +impl<'a> _EXCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABIEW<'a> { + w: &'a mut W, +} +impl<'a> _CKABIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDIEW<'a> { + w: &'a mut W, +} +impl<'a> _SCDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDIEW<'a> { + w: &'a mut W, +} +impl<'a> _AWDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ROVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ROVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JOVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _JOVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _REOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&self) -> AWDCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWDCHR { bits } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&self) -> EXCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXCHR { bits } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&self) -> CKABIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABIER { bits } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&self) -> SCDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDIER { bits } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&self) -> AWDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDIER { bits } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&self) -> ROVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRIER { bits } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&self) -> JOVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRIER { bits } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&self) -> REOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCIER { bits } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&self) -> JEOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&mut self) -> _AWDCHW { + _AWDCHW { w: self } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&mut self) -> _EXCHW { + _EXCHW { w: self } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&mut self) -> _CKABIEW { + _CKABIEW { w: self } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&mut self) -> _SCDIEW { + _SCDIEW { w: self } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&mut self) -> _AWDIEW { + _AWDIEW { w: self } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&mut self) -> _ROVRIEW { + _ROVRIEW { w: self } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&mut self) -> _JOVRIEW { + _JOVRIEW { w: self } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&mut self) -> _REOCIEW { + _REOCIEW { w: self } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&mut self) -> _JEOCIEW { + _JEOCIEW { w: self } + } +} diff --git a/src/dfsdm1/flt1exmax/mod.rs b/src/dfsdm1/flt1exmax/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0ce57170bb93a17fad23860806f83a3a3151ba69 --- /dev/null +++ b/src/dfsdm1/flt1exmax/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1EXMAX { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMAXR { + bits: u32, +} +impl EXMAXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMAXCHR { + bits: u8, +} +impl EXMAXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Extremes detector maximum value"] + #[inline] + pub fn exmax(&self) -> EXMAXR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMAXR { bits } + } + #[doc = "Bits 0:2 - Extremes detector maximum data channel"] + #[inline] + pub fn exmaxch(&self) -> EXMAXCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMAXCHR { bits } + } +} diff --git a/src/dfsdm1/flt1exmin/mod.rs b/src/dfsdm1/flt1exmin/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5b475191a732d4982206cdd9e493e616771000a8 --- /dev/null +++ b/src/dfsdm1/flt1exmin/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1EXMIN { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMINR { + bits: u32, +} +impl EXMINR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMINCHR { + bits: u8, +} +impl EXMINCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - EXMIN"] + #[inline] + pub fn exmin(&self) -> EXMINR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMINR { bits } + } + #[doc = "Bits 0:2 - Extremes detector minimum data channel"] + #[inline] + pub fn exminch(&self) -> EXMINCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMINCHR { bits } + } +} diff --git a/src/dfsdm1/flt1fcr/mod.rs b/src/dfsdm1/flt1fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..792600686c0aff8cb91ff098f691b1bc18885421 --- /dev/null +++ b/src/dfsdm1/flt1fcr/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FORDR { + bits: u8, +} +impl FORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FOSRR { + bits: u16, +} +impl FOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOSRR { + bits: u8, +} +impl IOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FORDW<'a> { + w: &'a mut W, +} +impl<'a> _FORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOSRW<'a> { + w: &'a mut W, +} +impl<'a> _FOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOSRW<'a> { + w: &'a mut W, +} +impl<'a> _IOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&self) -> FORDR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FORDR { bits } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&self) -> FOSRR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FOSRR { bits } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&self) -> IOSRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOSRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&mut self) -> _FORDW { + _FORDW { w: self } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&mut self) -> _FOSRW { + _FOSRW { w: self } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&mut self) -> _IOSRW { + _IOSRW { w: self } + } +} diff --git a/src/dfsdm1/flt1icr/mod.rs b/src/dfsdm1/flt1icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..210d228e2a32edc585247eba0332dca95d2cdbdf --- /dev/null +++ b/src/dfsdm1/flt1icr/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1ICR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRSCDFR { + bits: u8, +} +impl CLRSCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRCKABFR { + bits: u8, +} +impl CLRCKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRROVRFR { + bits: bool, +} +impl CLRROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLRJOVRFR { + bits: bool, +} +impl CLRJOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CLRSCDFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRSCDFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRCKABFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRCKABFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRROVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRROVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRJOVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRJOVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&self) -> CLRSCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRSCDFR { bits } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&self) -> CLRCKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRCKABFR { bits } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&self) -> CLRROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRROVRFR { bits } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&self) -> CLRJOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRJOVRFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&mut self) -> _CLRSCDFW { + _CLRSCDFW { w: self } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&mut self) -> _CLRCKABFW { + _CLRCKABFW { w: self } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&mut self) -> _CLRROVRFW { + _CLRROVRFW { w: self } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&mut self) -> _CLRJOVRFW { + _CLRJOVRFW { w: self } + } +} diff --git a/src/dfsdm1/flt1isr/mod.rs b/src/dfsdm1/flt1isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d29709596a6fd4166a3835984ba6a48b7a3b59cc --- /dev/null +++ b/src/dfsdm1/flt1isr/mod.rs @@ -0,0 +1,279 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1ISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SCDFR { + bits: u8, +} +impl SCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABFR { + bits: u8, +} +impl CKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RCIPR { + bits: bool, +} +impl RCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JCIPR { + bits: bool, +} +impl JCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDFR { + bits: bool, +} +impl AWDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRFR { + bits: bool, +} +impl ROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRFR { + bits: bool, +} +impl JOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCFR { + bits: bool, +} +impl REOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCFR { + bits: bool, +} +impl JEOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - short-circuit detector flag"] + #[inline] + pub fn scdf(&self) -> SCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDFR { bits } + } + #[doc = "Bits 16:23 - Clock absence flag"] + #[inline] + pub fn ckabf(&self) -> CKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKABFR { bits } + } + #[doc = "Bit 14 - Regular conversion in progress status"] + #[inline] + pub fn rcip(&self) -> RCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCIPR { bits } + } + #[doc = "Bit 13 - Injected conversion in progress status"] + #[inline] + pub fn jcip(&self) -> JCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JCIPR { bits } + } + #[doc = "Bit 4 - Analog watchdog"] + #[inline] + pub fn awdf(&self) -> AWDFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDFR { bits } + } + #[doc = "Bit 3 - Regular conversion overrun flag"] + #[inline] + pub fn rovrf(&self) -> ROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRFR { bits } + } + #[doc = "Bit 2 - Injected conversion overrun flag"] + #[inline] + pub fn jovrf(&self) -> JOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRFR { bits } + } + #[doc = "Bit 1 - End of regular conversion flag"] + #[inline] + pub fn reocf(&self) -> REOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCFR { bits } + } + #[doc = "Bit 0 - End of injected conversion flag"] + #[inline] + pub fn jeocf(&self) -> JEOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCFR { bits } + } +} diff --git a/src/dfsdm1/flt1jchgr/mod.rs b/src/dfsdm1/flt1jchgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b46e34e316188b9ebaad90abfc11a3fa4e052a68 --- /dev/null +++ b/src/dfsdm1/flt1jchgr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT1JCHGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JCHGR { + bits: u8, +} +impl JCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JCHGW<'a> { + w: &'a mut W, +} +impl<'a> _JCHGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&self) -> JCHGR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JCHGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&mut self) -> _JCHGW { + _JCHGW { w: self } + } +} diff --git a/src/dfsdm1/flt1jdatar/mod.rs b/src/dfsdm1/flt1jdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7efc171e36ccf42da3a525cd0409961e90bd443f --- /dev/null +++ b/src/dfsdm1/flt1jdatar/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1JDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u32, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDATACHR { + bits: u8, +} +impl JDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Injected group conversion data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + JDATAR { bits } + } + #[doc = "Bits 0:2 - Injected channel most recently converted"] + #[inline] + pub fn jdatach(&self) -> JDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt1rdatar/mod.rs b/src/dfsdm1/flt1rdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..04d571a7444aed9944dcf2d6e218b28affd0c743 --- /dev/null +++ b/src/dfsdm1/flt1rdatar/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT1RDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RDATAR { + bits: u32, +} +impl RDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RPENDR { + bits: bool, +} +impl RPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDATACHR { + bits: u8, +} +impl RDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Regular channel conversion data"] + #[inline] + pub fn rdata(&self) -> RDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + RDATAR { bits } + } + #[doc = "Bit 4 - Regular channel pending data"] + #[inline] + pub fn rpend(&self) -> RPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RPENDR { bits } + } + #[doc = "Bits 0:2 - Regular channel most recently converted"] + #[inline] + pub fn rdatach(&self) -> RDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt2awcfr/mod.rs b/src/dfsdm1/flt2awcfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5921204711e815a689f2c88de3ee1c2db60dce8f --- /dev/null +++ b/src/dfsdm1/flt2awcfr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2AWCFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRAWHTFR { + bits: u8, +} +impl CLRAWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRAWLTFR { + bits: u8, +} +impl CLRAWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CLRAWHTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWHTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRAWLTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWLTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&self) -> CLRAWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWHTFR { bits } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&self) -> CLRAWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWLTFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&mut self) -> _CLRAWHTFW { + _CLRAWHTFW { w: self } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&mut self) -> _CLRAWLTFW { + _CLRAWLTFW { w: self } + } +} diff --git a/src/dfsdm1/flt2awhtr/mod.rs b/src/dfsdm1/flt2awhtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dca86dca9c00dc6f015328bde8b67b5674ecd168 --- /dev/null +++ b/src/dfsdm1/flt2awhtr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2AWHTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWHTR { + bits: u32, +} +impl AWHTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWHR { + bits: u8, +} +impl BKAWHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWHTW<'a> { + w: &'a mut W, +} +impl<'a> _AWHTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWHW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&self) -> AWHTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWHTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&self) -> BKAWHR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&mut self) -> _AWHTW { + _AWHTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&mut self) -> _BKAWHW { + _BKAWHW { w: self } + } +} diff --git a/src/dfsdm1/flt2awltr/mod.rs b/src/dfsdm1/flt2awltr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0d9a7e7c624a0a64d8691a89abe8d01d9b450e2e --- /dev/null +++ b/src/dfsdm1/flt2awltr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2AWLTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWLTR { + bits: u32, +} +impl AWLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWLR { + bits: u8, +} +impl BKAWLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWLTW<'a> { + w: &'a mut W, +} +impl<'a> _AWLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWLW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&self) -> AWLTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWLTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&self) -> BKAWLR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&mut self) -> _AWLTW { + _AWLTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&mut self) -> _BKAWLW { + _BKAWLW { w: self } + } +} diff --git a/src/dfsdm1/flt2awsr/mod.rs b/src/dfsdm1/flt2awsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f4694051f56618bc1d746e7b7de5ff5cd90ae0e4 --- /dev/null +++ b/src/dfsdm1/flt2awsr/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2AWSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct AWHTFR { + bits: u8, +} +impl AWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWLTFR { + bits: u8, +} +impl AWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Analog watchdog high threshold flag"] + #[inline] + pub fn awhtf(&self) -> AWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWHTFR { bits } + } + #[doc = "Bits 0:7 - Analog watchdog low threshold flag"] + #[inline] + pub fn awltf(&self) -> AWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWLTFR { bits } + } +} diff --git a/src/dfsdm1/flt2cnvtimr/mod.rs b/src/dfsdm1/flt2cnvtimr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f9a18943676370c9f251bb82ac6eb9c8d362cf0b --- /dev/null +++ b/src/dfsdm1/flt2cnvtimr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2CNVTIMR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CNVCNTR { + bits: u32, +} +impl CNVCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN"] + #[inline] + pub fn cnvcnt(&self) -> CNVCNTR { + let bits = { + const MASK: u32 = 268435455; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CNVCNTR { bits } + } +} diff --git a/src/dfsdm1/flt2cr1/mod.rs b/src/dfsdm1/flt2cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..07f516589ca1d0a9140ff5d7bbccf2604ab19c1e --- /dev/null +++ b/src/dfsdm1/flt2cr1/mod.rs @@ -0,0 +1,836 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFSELR { + bits: bool, +} +impl AWFSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FASTR { + bits: bool, +} +impl FASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCHR { + bits: u8, +} +impl RCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RDMAENR { + bits: bool, +} +impl RDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSYNCR { + bits: bool, +} +impl RSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCONTR { + bits: bool, +} +impl RCONTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSWSTARTR { + bits: bool, +} +impl RSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEXTENR { + bits: u8, +} +impl JEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JEXTSELR { + bits: u8, +} +impl JEXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDMAENR { + bits: bool, +} +impl JDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSCANR { + bits: bool, +} +impl JSCANR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSYNCR { + bits: bool, +} +impl JSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSWSTARTR { + bits: bool, +} +impl JSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFENR { + bits: bool, +} +impl DFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWFSELW<'a> { + w: &'a mut W, +} +impl<'a> _AWFSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FASTW<'a> { + w: &'a mut W, +} +impl<'a> _FASTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCHW<'a> { + w: &'a mut W, +} +impl<'a> _RCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _RSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCONTW<'a> { + w: &'a mut W, +} +impl<'a> _RCONTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _RSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _JDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSCANW<'a> { + w: &'a mut W, +} +impl<'a> _JSCANW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _JSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _JSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFENW<'a> { + w: &'a mut W, +} +impl<'a> _DFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&self) -> AWFSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWFSELR { bits } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&self) -> FASTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FASTR { bits } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&self) -> RCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RCHR { bits } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&self) -> RDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RDMAENR { bits } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&self) -> RSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSYNCR { bits } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&self) -> RCONTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCONTR { bits } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&self) -> RSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSWSTARTR { bits } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&self) -> JEXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTENR { bits } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&self) -> JEXTSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTSELR { bits } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&self) -> JDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JDMAENR { bits } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&self) -> JSCANR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSCANR { bits } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&self) -> JSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSYNCR { bits } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&self) -> JSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSWSTARTR { bits } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&self) -> DFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&mut self) -> _AWFSELW { + _AWFSELW { w: self } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&mut self) -> _FASTW { + _FASTW { w: self } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&mut self) -> _RCHW { + _RCHW { w: self } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&mut self) -> _RDMAENW { + _RDMAENW { w: self } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&mut self) -> _RSYNCW { + _RSYNCW { w: self } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&mut self) -> _RCONTW { + _RCONTW { w: self } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&mut self) -> _RSWSTARTW { + _RSWSTARTW { w: self } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&mut self) -> _JEXTENW { + _JEXTENW { w: self } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&mut self) -> _JEXTSELW { + _JEXTSELW { w: self } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&mut self) -> _JDMAENW { + _JDMAENW { w: self } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&mut self) -> _JSCANW { + _JSCANW { w: self } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&mut self) -> _JSYNCW { + _JSYNCW { w: self } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&mut self) -> _JSWSTARTW { + _JSWSTARTW { w: self } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&mut self) -> _DFENW { + _DFENW { w: self } + } +} diff --git a/src/dfsdm1/flt2cr2/mod.rs b/src/dfsdm1/flt2cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..79df7ebc9a52132a80c5a1f5782f04e0b4f99904 --- /dev/null +++ b/src/dfsdm1/flt2cr2/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWDCHR { + bits: u8, +} +impl AWDCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXCHR { + bits: u8, +} +impl EXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABIER { + bits: bool, +} +impl CKABIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDIER { + bits: bool, +} +impl SCDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDIER { + bits: bool, +} +impl AWDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRIER { + bits: bool, +} +impl ROVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRIER { + bits: bool, +} +impl JOVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCIER { + bits: bool, +} +impl REOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCIER { + bits: bool, +} +impl JEOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWDCHW<'a> { + w: &'a mut W, +} +impl<'a> _AWDCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXCHW<'a> { + w: &'a mut W, +} +impl<'a> _EXCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABIEW<'a> { + w: &'a mut W, +} +impl<'a> _CKABIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDIEW<'a> { + w: &'a mut W, +} +impl<'a> _SCDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDIEW<'a> { + w: &'a mut W, +} +impl<'a> _AWDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ROVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ROVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JOVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _JOVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _REOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&self) -> AWDCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWDCHR { bits } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&self) -> EXCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXCHR { bits } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&self) -> CKABIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABIER { bits } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&self) -> SCDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDIER { bits } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&self) -> AWDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDIER { bits } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&self) -> ROVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRIER { bits } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&self) -> JOVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRIER { bits } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&self) -> REOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCIER { bits } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&self) -> JEOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&mut self) -> _AWDCHW { + _AWDCHW { w: self } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&mut self) -> _EXCHW { + _EXCHW { w: self } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&mut self) -> _CKABIEW { + _CKABIEW { w: self } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&mut self) -> _SCDIEW { + _SCDIEW { w: self } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&mut self) -> _AWDIEW { + _AWDIEW { w: self } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&mut self) -> _ROVRIEW { + _ROVRIEW { w: self } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&mut self) -> _JOVRIEW { + _JOVRIEW { w: self } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&mut self) -> _REOCIEW { + _REOCIEW { w: self } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&mut self) -> _JEOCIEW { + _JEOCIEW { w: self } + } +} diff --git a/src/dfsdm1/flt2exmax/mod.rs b/src/dfsdm1/flt2exmax/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6fd7ed66e71951316bd6752e8c2af543ed693b1 --- /dev/null +++ b/src/dfsdm1/flt2exmax/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2EXMAX { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMAXR { + bits: u32, +} +impl EXMAXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMAXCHR { + bits: u8, +} +impl EXMAXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Extremes detector maximum value"] + #[inline] + pub fn exmax(&self) -> EXMAXR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMAXR { bits } + } + #[doc = "Bits 0:2 - Extremes detector maximum data channel"] + #[inline] + pub fn exmaxch(&self) -> EXMAXCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMAXCHR { bits } + } +} diff --git a/src/dfsdm1/flt2exmin/mod.rs b/src/dfsdm1/flt2exmin/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8e77d2a5cf6be5e14bf38d56f5aea3e786f7b3b4 --- /dev/null +++ b/src/dfsdm1/flt2exmin/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2EXMIN { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMINR { + bits: u32, +} +impl EXMINR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMINCHR { + bits: u8, +} +impl EXMINCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - EXMIN"] + #[inline] + pub fn exmin(&self) -> EXMINR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMINR { bits } + } + #[doc = "Bits 0:2 - Extremes detector minimum data channel"] + #[inline] + pub fn exminch(&self) -> EXMINCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMINCHR { bits } + } +} diff --git a/src/dfsdm1/flt2fcr/mod.rs b/src/dfsdm1/flt2fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d2c59f74f248084ecaf8827641048a44adf2b551 --- /dev/null +++ b/src/dfsdm1/flt2fcr/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FORDR { + bits: u8, +} +impl FORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FOSRR { + bits: u16, +} +impl FOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOSRR { + bits: u8, +} +impl IOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FORDW<'a> { + w: &'a mut W, +} +impl<'a> _FORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOSRW<'a> { + w: &'a mut W, +} +impl<'a> _FOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOSRW<'a> { + w: &'a mut W, +} +impl<'a> _IOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&self) -> FORDR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FORDR { bits } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&self) -> FOSRR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FOSRR { bits } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&self) -> IOSRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOSRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&mut self) -> _FORDW { + _FORDW { w: self } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&mut self) -> _FOSRW { + _FOSRW { w: self } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&mut self) -> _IOSRW { + _IOSRW { w: self } + } +} diff --git a/src/dfsdm1/flt2icr/mod.rs b/src/dfsdm1/flt2icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bf192e5cb974137705caf9e7babd6cbe9d3f5207 --- /dev/null +++ b/src/dfsdm1/flt2icr/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2ICR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRSCDFR { + bits: u8, +} +impl CLRSCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRCKABFR { + bits: u8, +} +impl CLRCKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRROVRFR { + bits: bool, +} +impl CLRROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLRJOVRFR { + bits: bool, +} +impl CLRJOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CLRSCDFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRSCDFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRCKABFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRCKABFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRROVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRROVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRJOVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRJOVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&self) -> CLRSCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRSCDFR { bits } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&self) -> CLRCKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRCKABFR { bits } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&self) -> CLRROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRROVRFR { bits } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&self) -> CLRJOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRJOVRFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&mut self) -> _CLRSCDFW { + _CLRSCDFW { w: self } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&mut self) -> _CLRCKABFW { + _CLRCKABFW { w: self } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&mut self) -> _CLRROVRFW { + _CLRROVRFW { w: self } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&mut self) -> _CLRJOVRFW { + _CLRJOVRFW { w: self } + } +} diff --git a/src/dfsdm1/flt2isr/mod.rs b/src/dfsdm1/flt2isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50ddad2a0a093ccb77daead0b440c8f8895cc3f6 --- /dev/null +++ b/src/dfsdm1/flt2isr/mod.rs @@ -0,0 +1,279 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2ISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SCDFR { + bits: u8, +} +impl SCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABFR { + bits: u8, +} +impl CKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RCIPR { + bits: bool, +} +impl RCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JCIPR { + bits: bool, +} +impl JCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDFR { + bits: bool, +} +impl AWDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRFR { + bits: bool, +} +impl ROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRFR { + bits: bool, +} +impl JOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCFR { + bits: bool, +} +impl REOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCFR { + bits: bool, +} +impl JEOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - short-circuit detector flag"] + #[inline] + pub fn scdf(&self) -> SCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDFR { bits } + } + #[doc = "Bits 16:23 - Clock absence flag"] + #[inline] + pub fn ckabf(&self) -> CKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKABFR { bits } + } + #[doc = "Bit 14 - Regular conversion in progress status"] + #[inline] + pub fn rcip(&self) -> RCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCIPR { bits } + } + #[doc = "Bit 13 - Injected conversion in progress status"] + #[inline] + pub fn jcip(&self) -> JCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JCIPR { bits } + } + #[doc = "Bit 4 - Analog watchdog"] + #[inline] + pub fn awdf(&self) -> AWDFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDFR { bits } + } + #[doc = "Bit 3 - Regular conversion overrun flag"] + #[inline] + pub fn rovrf(&self) -> ROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRFR { bits } + } + #[doc = "Bit 2 - Injected conversion overrun flag"] + #[inline] + pub fn jovrf(&self) -> JOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRFR { bits } + } + #[doc = "Bit 1 - End of regular conversion flag"] + #[inline] + pub fn reocf(&self) -> REOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCFR { bits } + } + #[doc = "Bit 0 - End of injected conversion flag"] + #[inline] + pub fn jeocf(&self) -> JEOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCFR { bits } + } +} diff --git a/src/dfsdm1/flt2jchgr/mod.rs b/src/dfsdm1/flt2jchgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d5759288e7ef21b4cabc0986f59fb8f3bdacf756 --- /dev/null +++ b/src/dfsdm1/flt2jchgr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT2JCHGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JCHGR { + bits: u8, +} +impl JCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JCHGW<'a> { + w: &'a mut W, +} +impl<'a> _JCHGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&self) -> JCHGR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JCHGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&mut self) -> _JCHGW { + _JCHGW { w: self } + } +} diff --git a/src/dfsdm1/flt2jdatar/mod.rs b/src/dfsdm1/flt2jdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab0873987797a9c181728b06a5a8e7d42b1bd6db --- /dev/null +++ b/src/dfsdm1/flt2jdatar/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2JDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u32, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDATACHR { + bits: u8, +} +impl JDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Injected group conversion data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + JDATAR { bits } + } + #[doc = "Bits 0:2 - Injected channel most recently converted"] + #[inline] + pub fn jdatach(&self) -> JDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt2rdatar/mod.rs b/src/dfsdm1/flt2rdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a9e3d7f6941601a4565cb55d5ab4937b1fc21c30 --- /dev/null +++ b/src/dfsdm1/flt2rdatar/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT2RDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RDATAR { + bits: u32, +} +impl RDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RPENDR { + bits: bool, +} +impl RPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDATACHR { + bits: u8, +} +impl RDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Regular channel conversion data"] + #[inline] + pub fn rdata(&self) -> RDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + RDATAR { bits } + } + #[doc = "Bit 4 - Regular channel pending data"] + #[inline] + pub fn rpend(&self) -> RPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RPENDR { bits } + } + #[doc = "Bits 0:2 - Regular channel most recently converted"] + #[inline] + pub fn rdatach(&self) -> RDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt3awcfr/mod.rs b/src/dfsdm1/flt3awcfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0d6a341f9266e16864ce1783d156e06516b5265c --- /dev/null +++ b/src/dfsdm1/flt3awcfr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3AWCFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRAWHTFR { + bits: u8, +} +impl CLRAWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRAWLTFR { + bits: u8, +} +impl CLRAWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CLRAWHTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWHTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRAWLTFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRAWLTFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&self) -> CLRAWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWHTFR { bits } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&self) -> CLRAWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRAWLTFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - Clear the analog watchdog high threshold flag"] + #[inline] + pub fn clrawhtf(&mut self) -> _CLRAWHTFW { + _CLRAWHTFW { w: self } + } + #[doc = "Bits 0:7 - Clear the analog watchdog low threshold flag"] + #[inline] + pub fn clrawltf(&mut self) -> _CLRAWLTFW { + _CLRAWLTFW { w: self } + } +} diff --git a/src/dfsdm1/flt3awhtr/mod.rs b/src/dfsdm1/flt3awhtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..723bf4556531fb2dd21dca60ee08d16aec93641b --- /dev/null +++ b/src/dfsdm1/flt3awhtr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3AWHTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWHTR { + bits: u32, +} +impl AWHTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWHR { + bits: u8, +} +impl BKAWHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWHTW<'a> { + w: &'a mut W, +} +impl<'a> _AWHTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWHW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&self) -> AWHTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWHTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&self) -> BKAWHR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog high threshold"] + #[inline] + pub fn awht(&mut self) -> _AWHTW { + _AWHTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog high threshold event"] + #[inline] + pub fn bkawh(&mut self) -> _BKAWHW { + _BKAWHW { w: self } + } +} diff --git a/src/dfsdm1/flt3awltr/mod.rs b/src/dfsdm1/flt3awltr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a368fed6fee382dce16fa0f788005b1435cc6e6f --- /dev/null +++ b/src/dfsdm1/flt3awltr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3AWLTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWLTR { + bits: u32, +} +impl AWLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BKAWLR { + bits: u8, +} +impl BKAWLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AWLTW<'a> { + w: &'a mut W, +} +impl<'a> _AWLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKAWLW<'a> { + w: &'a mut W, +} +impl<'a> _BKAWLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&self) -> AWLTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + AWLTR { bits } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&self) -> BKAWLR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BKAWLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:31 - Analog watchdog low threshold"] + #[inline] + pub fn awlt(&mut self) -> _AWLTW { + _AWLTW { w: self } + } + #[doc = "Bits 0:3 - Break signal assignment to analog watchdog low threshold event"] + #[inline] + pub fn bkawl(&mut self) -> _BKAWLW { + _BKAWLW { w: self } + } +} diff --git a/src/dfsdm1/flt3awsr/mod.rs b/src/dfsdm1/flt3awsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fea7c00077e99c140cbeee7c7926d8ebbf02dfb4 --- /dev/null +++ b/src/dfsdm1/flt3awsr/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3AWSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct AWHTFR { + bits: u8, +} +impl AWHTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AWLTFR { + bits: u8, +} +impl AWLTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Analog watchdog high threshold flag"] + #[inline] + pub fn awhtf(&self) -> AWHTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWHTFR { bits } + } + #[doc = "Bits 0:7 - Analog watchdog low threshold flag"] + #[inline] + pub fn awltf(&self) -> AWLTFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWLTFR { bits } + } +} diff --git a/src/dfsdm1/flt3cnvtimr/mod.rs b/src/dfsdm1/flt3cnvtimr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f618662e6c7cb8d58ebf2b18237ad45bd89b61c0 --- /dev/null +++ b/src/dfsdm1/flt3cnvtimr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3CNVTIMR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CNVCNTR { + bits: u32, +} +impl CNVCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:31 - 28-bit timer counting conversion time t = CNVCNT[27:0] / fDFSDM_CKIN"] + #[inline] + pub fn cnvcnt(&self) -> CNVCNTR { + let bits = { + const MASK: u32 = 268435455; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CNVCNTR { bits } + } +} diff --git a/src/dfsdm1/flt3cr1/mod.rs b/src/dfsdm1/flt3cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0a6a8cc41356ad9e6b41f29fac513cc2bda40b2d --- /dev/null +++ b/src/dfsdm1/flt3cr1/mod.rs @@ -0,0 +1,836 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWFSELR { + bits: bool, +} +impl AWFSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FASTR { + bits: bool, +} +impl FASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCHR { + bits: u8, +} +impl RCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RDMAENR { + bits: bool, +} +impl RDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSYNCR { + bits: bool, +} +impl RSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCONTR { + bits: bool, +} +impl RCONTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSWSTARTR { + bits: bool, +} +impl RSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEXTENR { + bits: u8, +} +impl JEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JEXTSELR { + bits: u8, +} +impl JEXTSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDMAENR { + bits: bool, +} +impl JDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSCANR { + bits: bool, +} +impl JSCANR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSYNCR { + bits: bool, +} +impl JSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JSWSTARTR { + bits: bool, +} +impl JSWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFENR { + bits: bool, +} +impl DFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWFSELW<'a> { + w: &'a mut W, +} +impl<'a> _AWFSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FASTW<'a> { + w: &'a mut W, +} +impl<'a> _FASTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCHW<'a> { + w: &'a mut W, +} +impl<'a> _RCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _RSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCONTW<'a> { + w: &'a mut W, +} +impl<'a> _RCONTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _RSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEXTSELW<'a> { + w: &'a mut W, +} +impl<'a> _JEXTSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _JDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSCANW<'a> { + w: &'a mut W, +} +impl<'a> _JSCANW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _JSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JSWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _JSWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFENW<'a> { + w: &'a mut W, +} +impl<'a> _DFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&self) -> AWFSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWFSELR { bits } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&self) -> FASTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FASTR { bits } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&self) -> RCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RCHR { bits } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&self) -> RDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RDMAENR { bits } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&self) -> RSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSYNCR { bits } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&self) -> RCONTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCONTR { bits } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&self) -> RSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSWSTARTR { bits } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&self) -> JEXTENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTENR { bits } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&self) -> JEXTSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JEXTSELR { bits } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&self) -> JDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JDMAENR { bits } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&self) -> JSCANR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSCANR { bits } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&self) -> JSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSYNCR { bits } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&self) -> JSWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JSWSTARTR { bits } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&self) -> DFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 30 - Analog watchdog fast mode select"] + #[inline] + pub fn awfsel(&mut self) -> _AWFSELW { + _AWFSELW { w: self } + } + #[doc = "Bit 29 - Fast conversion mode selection for regular conversions"] + #[inline] + pub fn fast(&mut self) -> _FASTW { + _FASTW { w: self } + } + #[doc = "Bits 24:26 - Regular channel selection"] + #[inline] + pub fn rch(&mut self) -> _RCHW { + _RCHW { w: self } + } + #[doc = "Bit 21 - DMA channel enabled to read data for the regular conversion"] + #[inline] + pub fn rdmaen(&mut self) -> _RDMAENW { + _RDMAENW { w: self } + } + #[doc = "Bit 19 - Launch regular conversion synchronously with DFSDM0"] + #[inline] + pub fn rsync(&mut self) -> _RSYNCW { + _RSYNCW { w: self } + } + #[doc = "Bit 18 - Continuous mode selection for regular conversions"] + #[inline] + pub fn rcont(&mut self) -> _RCONTW { + _RCONTW { w: self } + } + #[doc = "Bit 17 - Software start of a conversion on the regular channel"] + #[inline] + pub fn rswstart(&mut self) -> _RSWSTARTW { + _RSWSTARTW { w: self } + } + #[doc = "Bits 13:14 - Trigger enable and trigger edge selection for injected conversions"] + #[inline] + pub fn jexten(&mut self) -> _JEXTENW { + _JEXTENW { w: self } + } + #[doc = "Bits 8:10 - Trigger signal selection for launching injected conversions"] + #[inline] + pub fn jextsel(&mut self) -> _JEXTSELW { + _JEXTSELW { w: self } + } + #[doc = "Bit 5 - DMA channel enabled to read data for the injected channel group"] + #[inline] + pub fn jdmaen(&mut self) -> _JDMAENW { + _JDMAENW { w: self } + } + #[doc = "Bit 4 - Scanning conversion mode for injected conversions"] + #[inline] + pub fn jscan(&mut self) -> _JSCANW { + _JSCANW { w: self } + } + #[doc = "Bit 3 - Launch an injected conversion synchronously with the DFSDM0 JSWSTART trigger"] + #[inline] + pub fn jsync(&mut self) -> _JSYNCW { + _JSYNCW { w: self } + } + #[doc = "Bit 1 - Start a conversion of the injected group of channels"] + #[inline] + pub fn jswstart(&mut self) -> _JSWSTARTW { + _JSWSTARTW { w: self } + } + #[doc = "Bit 0 - DFSDM enable"] + #[inline] + pub fn dfen(&mut self) -> _DFENW { + _DFENW { w: self } + } +} diff --git a/src/dfsdm1/flt3cr2/mod.rs b/src/dfsdm1/flt3cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dcbd8d2f555e39ac5760f82db86d06119feafbcc --- /dev/null +++ b/src/dfsdm1/flt3cr2/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AWDCHR { + bits: u8, +} +impl AWDCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXCHR { + bits: u8, +} +impl EXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABIER { + bits: bool, +} +impl CKABIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCDIER { + bits: bool, +} +impl SCDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDIER { + bits: bool, +} +impl AWDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRIER { + bits: bool, +} +impl ROVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRIER { + bits: bool, +} +impl JOVRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCIER { + bits: bool, +} +impl REOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCIER { + bits: bool, +} +impl JEOCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AWDCHW<'a> { + w: &'a mut W, +} +impl<'a> _AWDCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXCHW<'a> { + w: &'a mut W, +} +impl<'a> _EXCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKABIEW<'a> { + w: &'a mut W, +} +impl<'a> _CKABIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCDIEW<'a> { + w: &'a mut W, +} +impl<'a> _SCDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AWDIEW<'a> { + w: &'a mut W, +} +impl<'a> _AWDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ROVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ROVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JOVRIEW<'a> { + w: &'a mut W, +} +impl<'a> _JOVRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _REOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _JEOCIEW<'a> { + w: &'a mut W, +} +impl<'a> _JEOCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&self) -> AWDCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AWDCHR { bits } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&self) -> EXCHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXCHR { bits } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&self) -> CKABIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKABIER { bits } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&self) -> SCDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCDIER { bits } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&self) -> AWDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDIER { bits } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&self) -> ROVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRIER { bits } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&self) -> JOVRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRIER { bits } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&self) -> REOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCIER { bits } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&self) -> JEOCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:23 - Analog watchdog channel selection"] + #[inline] + pub fn awdch(&mut self) -> _AWDCHW { + _AWDCHW { w: self } + } + #[doc = "Bits 8:15 - Extremes detector channel selection"] + #[inline] + pub fn exch(&mut self) -> _EXCHW { + _EXCHW { w: self } + } + #[doc = "Bit 6 - Clock absence interrupt enable"] + #[inline] + pub fn ckabie(&mut self) -> _CKABIEW { + _CKABIEW { w: self } + } + #[doc = "Bit 5 - Short-circuit detector interrupt enable"] + #[inline] + pub fn scdie(&mut self) -> _SCDIEW { + _SCDIEW { w: self } + } + #[doc = "Bit 4 - Analog watchdog interrupt enable"] + #[inline] + pub fn awdie(&mut self) -> _AWDIEW { + _AWDIEW { w: self } + } + #[doc = "Bit 3 - Regular data overrun interrupt enable"] + #[inline] + pub fn rovrie(&mut self) -> _ROVRIEW { + _ROVRIEW { w: self } + } + #[doc = "Bit 2 - Injected data overrun interrupt enable"] + #[inline] + pub fn jovrie(&mut self) -> _JOVRIEW { + _JOVRIEW { w: self } + } + #[doc = "Bit 1 - Regular end of conversion interrupt enable"] + #[inline] + pub fn reocie(&mut self) -> _REOCIEW { + _REOCIEW { w: self } + } + #[doc = "Bit 0 - Injected end of conversion interrupt enable"] + #[inline] + pub fn jeocie(&mut self) -> _JEOCIEW { + _JEOCIEW { w: self } + } +} diff --git a/src/dfsdm1/flt3exmax/mod.rs b/src/dfsdm1/flt3exmax/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5076a30f5761084c83df0db798a60d04181b2723 --- /dev/null +++ b/src/dfsdm1/flt3exmax/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3EXMAX { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMAXR { + bits: u32, +} +impl EXMAXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMAXCHR { + bits: u8, +} +impl EXMAXCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Extremes detector maximum value"] + #[inline] + pub fn exmax(&self) -> EXMAXR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMAXR { bits } + } + #[doc = "Bits 0:2 - Extremes detector maximum data channel"] + #[inline] + pub fn exmaxch(&self) -> EXMAXCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMAXCHR { bits } + } +} diff --git a/src/dfsdm1/flt3exmin/mod.rs b/src/dfsdm1/flt3exmin/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8efdae2b0b5f7171303a7bd3b9b5700f4b3596be --- /dev/null +++ b/src/dfsdm1/flt3exmin/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3EXMIN { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EXMINR { + bits: u32, +} +impl EXMINR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXMINCHR { + bits: u8, +} +impl EXMINCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - EXMIN"] + #[inline] + pub fn exmin(&self) -> EXMINR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + EXMINR { bits } + } + #[doc = "Bits 0:2 - Extremes detector minimum data channel"] + #[inline] + pub fn exminch(&self) -> EXMINCHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXMINCHR { bits } + } +} diff --git a/src/dfsdm1/flt3fcr/mod.rs b/src/dfsdm1/flt3fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..62faaaeebe5d7b267b7c445526f2ac61bd704da8 --- /dev/null +++ b/src/dfsdm1/flt3fcr/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FORDR { + bits: u8, +} +impl FORDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FOSRR { + bits: u16, +} +impl FOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOSRR { + bits: u8, +} +impl IOSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FORDW<'a> { + w: &'a mut W, +} +impl<'a> _FORDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FOSRW<'a> { + w: &'a mut W, +} +impl<'a> _FOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOSRW<'a> { + w: &'a mut W, +} +impl<'a> _IOSRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&self) -> FORDR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FORDR { bits } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&self) -> FOSRR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FOSRR { bits } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&self) -> IOSRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOSRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:31 - Sinc filter order"] + #[inline] + pub fn ford(&mut self) -> _FORDW { + _FORDW { w: self } + } + #[doc = "Bits 16:25 - Sinc filter oversampling ratio (decimation rate)"] + #[inline] + pub fn fosr(&mut self) -> _FOSRW { + _FOSRW { w: self } + } + #[doc = "Bits 0:7 - Integrator oversampling ratio (averaging length)"] + #[inline] + pub fn iosr(&mut self) -> _IOSRW { + _IOSRW { w: self } + } +} diff --git a/src/dfsdm1/flt3icr/mod.rs b/src/dfsdm1/flt3icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1a2c0cc355e46cf7f1b942652821cabe1215941b --- /dev/null +++ b/src/dfsdm1/flt3icr/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3ICR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CLRSCDFR { + bits: u8, +} +impl CLRSCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRCKABFR { + bits: u8, +} +impl CLRCKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLRROVRFR { + bits: bool, +} +impl CLRROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLRJOVRFR { + bits: bool, +} +impl CLRJOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CLRSCDFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRSCDFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRCKABFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRCKABFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRROVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRROVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLRJOVRFW<'a> { + w: &'a mut W, +} +impl<'a> _CLRJOVRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&self) -> CLRSCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRSCDFR { bits } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&self) -> CLRCKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLRCKABFR { bits } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&self) -> CLRROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRROVRFR { bits } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&self) -> CLRJOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLRJOVRFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - Clear the short-circuit detector flag"] + #[inline] + pub fn clrscdf(&mut self) -> _CLRSCDFW { + _CLRSCDFW { w: self } + } + #[doc = "Bits 16:23 - Clear the clock absence flag"] + #[inline] + pub fn clrckabf(&mut self) -> _CLRCKABFW { + _CLRCKABFW { w: self } + } + #[doc = "Bit 3 - Clear the regular conversion overrun flag"] + #[inline] + pub fn clrrovrf(&mut self) -> _CLRROVRFW { + _CLRROVRFW { w: self } + } + #[doc = "Bit 2 - Clear the injected conversion overrun flag"] + #[inline] + pub fn clrjovrf(&mut self) -> _CLRJOVRFW { + _CLRJOVRFW { w: self } + } +} diff --git a/src/dfsdm1/flt3isr/mod.rs b/src/dfsdm1/flt3isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..29659dec867e32464486410fe98cca0b08d61089 --- /dev/null +++ b/src/dfsdm1/flt3isr/mod.rs @@ -0,0 +1,279 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3ISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SCDFR { + bits: u8, +} +impl SCDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKABFR { + bits: u8, +} +impl CKABFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RCIPR { + bits: bool, +} +impl RCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JCIPR { + bits: bool, +} +impl JCIPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AWDFR { + bits: bool, +} +impl AWDFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ROVRFR { + bits: bool, +} +impl ROVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JOVRFR { + bits: bool, +} +impl JOVRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REOCFR { + bits: bool, +} +impl REOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct JEOCFR { + bits: bool, +} +impl JEOCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - short-circuit detector flag"] + #[inline] + pub fn scdf(&self) -> SCDFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCDFR { bits } + } + #[doc = "Bits 16:23 - Clock absence flag"] + #[inline] + pub fn ckabf(&self) -> CKABFR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKABFR { bits } + } + #[doc = "Bit 14 - Regular conversion in progress status"] + #[inline] + pub fn rcip(&self) -> RCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCIPR { bits } + } + #[doc = "Bit 13 - Injected conversion in progress status"] + #[inline] + pub fn jcip(&self) -> JCIPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JCIPR { bits } + } + #[doc = "Bit 4 - Analog watchdog"] + #[inline] + pub fn awdf(&self) -> AWDFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AWDFR { bits } + } + #[doc = "Bit 3 - Regular conversion overrun flag"] + #[inline] + pub fn rovrf(&self) -> ROVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ROVRFR { bits } + } + #[doc = "Bit 2 - Injected conversion overrun flag"] + #[inline] + pub fn jovrf(&self) -> JOVRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JOVRFR { bits } + } + #[doc = "Bit 1 - End of regular conversion flag"] + #[inline] + pub fn reocf(&self) -> REOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REOCFR { bits } + } + #[doc = "Bit 0 - End of injected conversion flag"] + #[inline] + pub fn jeocf(&self) -> JEOCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + JEOCFR { bits } + } +} diff --git a/src/dfsdm1/flt3jchgr/mod.rs b/src/dfsdm1/flt3jchgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..164fb1b855f72aca3c37d6fb7526a991e4a2c963 --- /dev/null +++ b/src/dfsdm1/flt3jchgr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FLT3JCHGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct JCHGR { + bits: u8, +} +impl JCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _JCHGW<'a> { + w: &'a mut W, +} +impl<'a> _JCHGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&self) -> JCHGR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JCHGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Injected channel group selection"] + #[inline] + pub fn jchg(&mut self) -> _JCHGW { + _JCHGW { w: self } + } +} diff --git a/src/dfsdm1/flt3jdatar/mod.rs b/src/dfsdm1/flt3jdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ceff961823e106c5a16c219a265097e1b98249f0 --- /dev/null +++ b/src/dfsdm1/flt3jdatar/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3JDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct JDATAR { + bits: u32, +} +impl JDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct JDATACHR { + bits: u8, +} +impl JDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Injected group conversion data"] + #[inline] + pub fn jdata(&self) -> JDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + JDATAR { bits } + } + #[doc = "Bits 0:2 - Injected channel most recently converted"] + #[inline] + pub fn jdatach(&self) -> JDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + JDATACHR { bits } + } +} diff --git a/src/dfsdm1/flt3rdatar/mod.rs b/src/dfsdm1/flt3rdatar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5a3952c0deb6784276629f997ae6bdff2be62312 --- /dev/null +++ b/src/dfsdm1/flt3rdatar/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FLT3RDATAR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RDATAR { + bits: u32, +} +impl RDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RPENDR { + bits: bool, +} +impl RPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDATACHR { + bits: u8, +} +impl RDATACHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:31 - Regular channel conversion data"] + #[inline] + pub fn rdata(&self) -> RDATAR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + RDATAR { bits } + } + #[doc = "Bit 4 - Regular channel pending data"] + #[inline] + pub fn rpend(&self) -> RPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RPENDR { bits } + } + #[doc = "Bits 0:2 - Regular channel most recently converted"] + #[inline] + pub fn rdatach(&self) -> RDATACHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RDATACHR { bits } + } +} diff --git a/src/dfsdm1/mod.rs b/src/dfsdm1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..513631057b87c91e3e15ec0ac76c2061d8b1a1d1 --- /dev/null +++ b/src/dfsdm1/mod.rs @@ -0,0 +1,815 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - channel configuration y register"] + pub ch0cfgr1: CH0CFGR1, + #[doc = "0x04 - channel configuration y register"] + pub ch0cfgr2: CH0CFGR2, + #[doc = "0x08 - analog watchdog and short-circuit detector register"] + pub ch0awscdr: CH0AWSCDR, + #[doc = "0x0c - channel watchdog filter data register"] + pub ch0wdatr: CH0WDATR, + #[doc = "0x10 - channel data input register"] + pub ch0datinr: CH0DATINR, + _reserved0: [u8; 12usize], + #[doc = "0x20 - CHCFG1R1"] + pub ch1cfgr1: CH1CFGR1, + #[doc = "0x24 - CHCFG1R2"] + pub ch1cfgr2: CH1CFGR2, + #[doc = "0x28 - AWSCD1R"] + pub ch1awscdr: CH1AWSCDR, + #[doc = "0x2c - CHWDAT1R"] + pub ch1wdatr: CH1WDATR, + #[doc = "0x30 - CHDATIN1R"] + pub ch1datinr: CH1DATINR, + _reserved1: [u8; 12usize], + #[doc = "0x40 - CHCFG2R1"] + pub ch2cfgr1: CH2CFGR1, + #[doc = "0x44 - CHCFG2R2"] + pub ch2cfgr2: CH2CFGR2, + #[doc = "0x48 - AWSCD2R"] + pub ch2awscdr: CH2AWSCDR, + #[doc = "0x4c - CHWDAT2R"] + pub ch2wdatr: CH2WDATR, + #[doc = "0x50 - CHDATIN2R"] + pub ch2datinr: CH2DATINR, + _reserved2: [u8; 12usize], + #[doc = "0x60 - CHCFG3R1"] + pub ch3cfgr1: CH3CFGR1, + #[doc = "0x64 - CHCFG3R2"] + pub ch3cfgr2: CH3CFGR2, + #[doc = "0x68 - AWSCD3R"] + pub ch3awscdr: CH3AWSCDR, + #[doc = "0x6c - CHWDAT3R"] + pub ch3wdatr: CH3WDATR, + #[doc = "0x70 - CHDATIN3R"] + pub ch3datinr: CH3DATINR, + _reserved3: [u8; 12usize], + #[doc = "0x80 - CHCFG4R1"] + pub ch4cfgr1: CH4CFGR1, + #[doc = "0x84 - CHCFG4R2"] + pub ch4cfgr2: CH4CFGR2, + #[doc = "0x88 - AWSCD4R"] + pub ch4awscdr: CH4AWSCDR, + #[doc = "0x8c - CHWDAT4R"] + pub ch4wdatr: CH4WDATR, + #[doc = "0x90 - CHDATIN4R"] + pub ch4datinr: CH4DATINR, + _reserved4: [u8; 12usize], + #[doc = "0xa0 - CHCFG5R1"] + pub ch5cfgr1: CH5CFGR1, + #[doc = "0xa4 - CHCFG5R2"] + pub ch5cfgr2: CH5CFGR2, + #[doc = "0xa8 - AWSCD5R"] + pub ch5awscdr: CH5AWSCDR, + #[doc = "0xac - CHWDAT5R"] + pub ch5wdatr: CH5WDATR, + #[doc = "0xb0 - CHDATIN5R"] + pub ch5datinr: CH5DATINR, + _reserved5: [u8; 12usize], + #[doc = "0xc0 - CHCFG6R1"] + pub ch6cfgr1: CH6CFGR1, + #[doc = "0xc4 - CHCFG6R2"] + pub ch6cfgr2: CH6CFGR2, + #[doc = "0xc8 - AWSCD6R"] + pub ch6awscdr: CH6AWSCDR, + #[doc = "0xcc - CHWDAT6R"] + pub ch6wdatr: CH6WDATR, + #[doc = "0xd0 - CHDATIN6R"] + pub ch6datinr: CH6DATINR, + _reserved6: [u8; 12usize], + #[doc = "0xe0 - CHCFG7R1"] + pub ch7cfgr1: CH7CFGR1, + #[doc = "0xe4 - CHCFG7R2"] + pub ch7cfgr2: CH7CFGR2, + #[doc = "0xe8 - AWSCD7R"] + pub ch7awscdr: CH7AWSCDR, + #[doc = "0xec - CHWDAT7R"] + pub ch7wdatr: CH7WDATR, + #[doc = "0xf0 - CHDATIN7R"] + pub ch7datinr: CH7DATINR, + _reserved7: [u8; 12usize], + #[doc = "0x100 - control register 1"] + pub flt0cr1: FLT0CR1, + #[doc = "0x104 - control register 2"] + pub flt0cr2: FLT0CR2, + #[doc = "0x108 - interrupt and status register"] + pub flt0isr: FLT0ISR, + #[doc = "0x10c - interrupt flag clear register"] + pub flt0icr: FLT0ICR, + #[doc = "0x110 - injected channel group selection register"] + pub flt0jchgr: FLT0JCHGR, + #[doc = "0x114 - filter control register"] + pub flt0fcr: FLT0FCR, + #[doc = "0x118 - data register for injected group"] + pub flt0jdatar: FLT0JDATAR, + #[doc = "0x11c - data register for the regular channel"] + pub flt0rdatar: FLT0RDATAR, + #[doc = "0x120 - analog watchdog high threshold register"] + pub flt0awhtr: FLT0AWHTR, + #[doc = "0x124 - analog watchdog low threshold register"] + pub flt0awltr: FLT0AWLTR, + #[doc = "0x128 - analog watchdog status register"] + pub flt0awsr: FLT0AWSR, + #[doc = "0x12c - analog watchdog clear flag register"] + pub flt0awcfr: FLT0AWCFR, + #[doc = "0x130 - Extremes detector maximum register"] + pub flt0exmax: FLT0EXMAX, + #[doc = "0x134 - Extremes detector minimum register"] + pub flt0exmin: FLT0EXMIN, + #[doc = "0x138 - conversion timer register"] + pub flt0cnvtimr: FLT0CNVTIMR, + _reserved8: [u8; 68usize], + #[doc = "0x180 - control register 1"] + pub flt1cr1: FLT1CR1, + #[doc = "0x184 - control register 2"] + pub flt1cr2: FLT1CR2, + #[doc = "0x188 - interrupt and status register"] + pub flt1isr: FLT1ISR, + #[doc = "0x18c - interrupt flag clear register"] + pub flt1icr: FLT1ICR, + #[doc = "0x190 - injected channel group selection register"] + pub flt1jchgr: FLT1JCHGR, + #[doc = "0x194 - filter control register"] + pub flt1fcr: FLT1FCR, + #[doc = "0x198 - data register for injected group"] + pub flt1jdatar: FLT1JDATAR, + #[doc = "0x19c - data register for the regular channel"] + pub flt1rdatar: FLT1RDATAR, + #[doc = "0x1a0 - analog watchdog high threshold register"] + pub flt1awhtr: FLT1AWHTR, + #[doc = "0x1a4 - analog watchdog low threshold register"] + pub flt1awltr: FLT1AWLTR, + #[doc = "0x1a8 - analog watchdog status register"] + pub flt1awsr: FLT1AWSR, + #[doc = "0x1ac - analog watchdog clear flag register"] + pub flt1awcfr: FLT1AWCFR, + #[doc = "0x1b0 - Extremes detector maximum register"] + pub flt1exmax: FLT1EXMAX, + #[doc = "0x1b4 - Extremes detector minimum register"] + pub flt1exmin: FLT1EXMIN, + #[doc = "0x1b8 - conversion timer register"] + pub flt1cnvtimr: FLT1CNVTIMR, + _reserved9: [u8; 68usize], + #[doc = "0x200 - control register 1"] + pub flt2cr1: FLT2CR1, + #[doc = "0x204 - control register 2"] + pub flt2cr2: FLT2CR2, + #[doc = "0x208 - interrupt and status register"] + pub flt2isr: FLT2ISR, + #[doc = "0x20c - interrupt flag clear register"] + pub flt2icr: FLT2ICR, + #[doc = "0x210 - injected channel group selection register"] + pub flt2jchgr: FLT2JCHGR, + #[doc = "0x214 - filter control register"] + pub flt2fcr: FLT2FCR, + #[doc = "0x218 - data register for injected group"] + pub flt2jdatar: FLT2JDATAR, + #[doc = "0x21c - data register for the regular channel"] + pub flt2rdatar: FLT2RDATAR, + #[doc = "0x220 - analog watchdog high threshold register"] + pub flt2awhtr: FLT2AWHTR, + #[doc = "0x224 - analog watchdog low threshold register"] + pub flt2awltr: FLT2AWLTR, + #[doc = "0x228 - analog watchdog status register"] + pub flt2awsr: FLT2AWSR, + #[doc = "0x22c - analog watchdog clear flag register"] + pub flt2awcfr: FLT2AWCFR, + #[doc = "0x230 - Extremes detector maximum register"] + pub flt2exmax: FLT2EXMAX, + #[doc = "0x234 - Extremes detector minimum register"] + pub flt2exmin: FLT2EXMIN, + #[doc = "0x238 - conversion timer register"] + pub flt2cnvtimr: FLT2CNVTIMR, + _reserved10: [u8; 68usize], + #[doc = "0x280 - control register 1"] + pub flt3cr1: FLT3CR1, + #[doc = "0x284 - control register 2"] + pub flt3cr2: FLT3CR2, + #[doc = "0x288 - interrupt and status register"] + pub flt3isr: FLT3ISR, + #[doc = "0x28c - interrupt flag clear register"] + pub flt3icr: FLT3ICR, + #[doc = "0x290 - injected channel group selection register"] + pub flt3jchgr: FLT3JCHGR, + #[doc = "0x294 - filter control register"] + pub flt3fcr: FLT3FCR, + #[doc = "0x298 - data register for injected group"] + pub flt3jdatar: FLT3JDATAR, + #[doc = "0x29c - data register for the regular channel"] + pub flt3rdatar: FLT3RDATAR, + #[doc = "0x2a0 - analog watchdog high threshold register"] + pub flt3awhtr: FLT3AWHTR, + #[doc = "0x2a4 - analog watchdog low threshold register"] + pub flt3awltr: FLT3AWLTR, + #[doc = "0x2a8 - analog watchdog status register"] + pub flt3awsr: FLT3AWSR, + #[doc = "0x2ac - analog watchdog clear flag register"] + pub flt3awcfr: FLT3AWCFR, + #[doc = "0x2b0 - Extremes detector maximum register"] + pub flt3exmax: FLT3EXMAX, + #[doc = "0x2b4 - Extremes detector minimum register"] + pub flt3exmin: FLT3EXMIN, + #[doc = "0x2b8 - conversion timer register"] + pub flt3cnvtimr: FLT3CNVTIMR, +} +#[doc = "channel configuration y register"] +pub struct CH0CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel configuration y register"] +pub mod ch0cfgr1; +#[doc = "channel configuration y register"] +pub struct CH0CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel configuration y register"] +pub mod ch0cfgr2; +#[doc = "analog watchdog and short-circuit detector register"] +pub struct CH0AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog and short-circuit detector register"] +pub mod ch0awscdr; +#[doc = "channel watchdog filter data register"] +pub struct CH0WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel watchdog filter data register"] +pub mod ch0wdatr; +#[doc = "channel data input register"] +pub struct CH0DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "channel data input register"] +pub mod ch0datinr; +#[doc = "CHCFG1R1"] +pub struct CH1CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG1R1"] +pub mod ch1cfgr1; +#[doc = "CHCFG1R2"] +pub struct CH1CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG1R2"] +pub mod ch1cfgr2; +#[doc = "AWSCD1R"] +pub struct CH1AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD1R"] +pub mod ch1awscdr; +#[doc = "CHWDAT1R"] +pub struct CH1WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT1R"] +pub mod ch1wdatr; +#[doc = "CHDATIN1R"] +pub struct CH1DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN1R"] +pub mod ch1datinr; +#[doc = "CHCFG2R1"] +pub struct CH2CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG2R1"] +pub mod ch2cfgr1; +#[doc = "CHCFG2R2"] +pub struct CH2CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG2R2"] +pub mod ch2cfgr2; +#[doc = "AWSCD2R"] +pub struct CH2AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD2R"] +pub mod ch2awscdr; +#[doc = "CHWDAT2R"] +pub struct CH2WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT2R"] +pub mod ch2wdatr; +#[doc = "CHDATIN2R"] +pub struct CH2DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN2R"] +pub mod ch2datinr; +#[doc = "CHCFG3R1"] +pub struct CH3CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG3R1"] +pub mod ch3cfgr1; +#[doc = "CHCFG3R2"] +pub struct CH3CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG3R2"] +pub mod ch3cfgr2; +#[doc = "AWSCD3R"] +pub struct CH3AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD3R"] +pub mod ch3awscdr; +#[doc = "CHWDAT3R"] +pub struct CH3WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT3R"] +pub mod ch3wdatr; +#[doc = "CHDATIN3R"] +pub struct CH3DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN3R"] +pub mod ch3datinr; +#[doc = "CHCFG4R1"] +pub struct CH4CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG4R1"] +pub mod ch4cfgr1; +#[doc = "CHCFG4R2"] +pub struct CH4CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG4R2"] +pub mod ch4cfgr2; +#[doc = "AWSCD4R"] +pub struct CH4AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD4R"] +pub mod ch4awscdr; +#[doc = "CHWDAT4R"] +pub struct CH4WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT4R"] +pub mod ch4wdatr; +#[doc = "CHDATIN4R"] +pub struct CH4DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN4R"] +pub mod ch4datinr; +#[doc = "CHCFG5R1"] +pub struct CH5CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG5R1"] +pub mod ch5cfgr1; +#[doc = "CHCFG5R2"] +pub struct CH5CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG5R2"] +pub mod ch5cfgr2; +#[doc = "AWSCD5R"] +pub struct CH5AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD5R"] +pub mod ch5awscdr; +#[doc = "CHWDAT5R"] +pub struct CH5WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT5R"] +pub mod ch5wdatr; +#[doc = "CHDATIN5R"] +pub struct CH5DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN5R"] +pub mod ch5datinr; +#[doc = "CHCFG6R1"] +pub struct CH6CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG6R1"] +pub mod ch6cfgr1; +#[doc = "CHCFG6R2"] +pub struct CH6CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG6R2"] +pub mod ch6cfgr2; +#[doc = "AWSCD6R"] +pub struct CH6AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD6R"] +pub mod ch6awscdr; +#[doc = "CHWDAT6R"] +pub struct CH6WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT6R"] +pub mod ch6wdatr; +#[doc = "CHDATIN6R"] +pub struct CH6DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN6R"] +pub mod ch6datinr; +#[doc = "CHCFG7R1"] +pub struct CH7CFGR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG7R1"] +pub mod ch7cfgr1; +#[doc = "CHCFG7R2"] +pub struct CH7CFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHCFG7R2"] +pub mod ch7cfgr2; +#[doc = "AWSCD7R"] +pub struct CH7AWSCDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AWSCD7R"] +pub mod ch7awscdr; +#[doc = "CHWDAT7R"] +pub struct CH7WDATR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHWDAT7R"] +pub mod ch7wdatr; +#[doc = "CHDATIN7R"] +pub struct CH7DATINR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CHDATIN7R"] +pub mod ch7datinr; +#[doc = "control register 1"] +pub struct FLT0CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod flt0cr1; +#[doc = "control register 2"] +pub struct FLT0CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod flt0cr2; +#[doc = "interrupt and status register"] +pub struct FLT0ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt and status register"] +pub mod flt0isr; +#[doc = "interrupt flag clear register"] +pub struct FLT0ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt flag clear register"] +pub mod flt0icr; +#[doc = "injected channel group selection register"] +pub struct FLT0JCHGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel group selection register"] +pub mod flt0jchgr; +#[doc = "filter control register"] +pub struct FLT0FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter control register"] +pub mod flt0fcr; +#[doc = "data register for injected group"] +pub struct FLT0JDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for injected group"] +pub mod flt0jdatar; +#[doc = "data register for the regular channel"] +pub struct FLT0RDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for the regular channel"] +pub mod flt0rdatar; +#[doc = "analog watchdog high threshold register"] +pub struct FLT0AWHTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog high threshold register"] +pub mod flt0awhtr; +#[doc = "analog watchdog low threshold register"] +pub struct FLT0AWLTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog low threshold register"] +pub mod flt0awltr; +#[doc = "analog watchdog status register"] +pub struct FLT0AWSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog status register"] +pub mod flt0awsr; +#[doc = "analog watchdog clear flag register"] +pub struct FLT0AWCFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog clear flag register"] +pub mod flt0awcfr; +#[doc = "Extremes detector maximum register"] +pub struct FLT0EXMAX { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector maximum register"] +pub mod flt0exmax; +#[doc = "Extremes detector minimum register"] +pub struct FLT0EXMIN { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector minimum register"] +pub mod flt0exmin; +#[doc = "conversion timer register"] +pub struct FLT0CNVTIMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "conversion timer register"] +pub mod flt0cnvtimr; +#[doc = "control register 1"] +pub struct FLT1CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod flt1cr1; +#[doc = "control register 2"] +pub struct FLT1CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod flt1cr2; +#[doc = "interrupt and status register"] +pub struct FLT1ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt and status register"] +pub mod flt1isr; +#[doc = "interrupt flag clear register"] +pub struct FLT1ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt flag clear register"] +pub mod flt1icr; +#[doc = "injected channel group selection register"] +pub struct FLT1JCHGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel group selection register"] +pub mod flt1jchgr; +#[doc = "filter control register"] +pub struct FLT1FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter control register"] +pub mod flt1fcr; +#[doc = "data register for injected group"] +pub struct FLT1JDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for injected group"] +pub mod flt1jdatar; +#[doc = "data register for the regular channel"] +pub struct FLT1RDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for the regular channel"] +pub mod flt1rdatar; +#[doc = "analog watchdog high threshold register"] +pub struct FLT1AWHTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog high threshold register"] +pub mod flt1awhtr; +#[doc = "analog watchdog low threshold register"] +pub struct FLT1AWLTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog low threshold register"] +pub mod flt1awltr; +#[doc = "analog watchdog status register"] +pub struct FLT1AWSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog status register"] +pub mod flt1awsr; +#[doc = "analog watchdog clear flag register"] +pub struct FLT1AWCFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog clear flag register"] +pub mod flt1awcfr; +#[doc = "Extremes detector maximum register"] +pub struct FLT1EXMAX { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector maximum register"] +pub mod flt1exmax; +#[doc = "Extremes detector minimum register"] +pub struct FLT1EXMIN { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector minimum register"] +pub mod flt1exmin; +#[doc = "conversion timer register"] +pub struct FLT1CNVTIMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "conversion timer register"] +pub mod flt1cnvtimr; +#[doc = "control register 1"] +pub struct FLT2CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod flt2cr1; +#[doc = "control register 2"] +pub struct FLT2CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod flt2cr2; +#[doc = "interrupt and status register"] +pub struct FLT2ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt and status register"] +pub mod flt2isr; +#[doc = "interrupt flag clear register"] +pub struct FLT2ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt flag clear register"] +pub mod flt2icr; +#[doc = "injected channel group selection register"] +pub struct FLT2JCHGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel group selection register"] +pub mod flt2jchgr; +#[doc = "filter control register"] +pub struct FLT2FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter control register"] +pub mod flt2fcr; +#[doc = "data register for injected group"] +pub struct FLT2JDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for injected group"] +pub mod flt2jdatar; +#[doc = "data register for the regular channel"] +pub struct FLT2RDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for the regular channel"] +pub mod flt2rdatar; +#[doc = "analog watchdog high threshold register"] +pub struct FLT2AWHTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog high threshold register"] +pub mod flt2awhtr; +#[doc = "analog watchdog low threshold register"] +pub struct FLT2AWLTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog low threshold register"] +pub mod flt2awltr; +#[doc = "analog watchdog status register"] +pub struct FLT2AWSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog status register"] +pub mod flt2awsr; +#[doc = "analog watchdog clear flag register"] +pub struct FLT2AWCFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog clear flag register"] +pub mod flt2awcfr; +#[doc = "Extremes detector maximum register"] +pub struct FLT2EXMAX { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector maximum register"] +pub mod flt2exmax; +#[doc = "Extremes detector minimum register"] +pub struct FLT2EXMIN { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector minimum register"] +pub mod flt2exmin; +#[doc = "conversion timer register"] +pub struct FLT2CNVTIMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "conversion timer register"] +pub mod flt2cnvtimr; +#[doc = "control register 1"] +pub struct FLT3CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod flt3cr1; +#[doc = "control register 2"] +pub struct FLT3CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod flt3cr2; +#[doc = "interrupt and status register"] +pub struct FLT3ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt and status register"] +pub mod flt3isr; +#[doc = "interrupt flag clear register"] +pub struct FLT3ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt flag clear register"] +pub mod flt3icr; +#[doc = "injected channel group selection register"] +pub struct FLT3JCHGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "injected channel group selection register"] +pub mod flt3jchgr; +#[doc = "filter control register"] +pub struct FLT3FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "filter control register"] +pub mod flt3fcr; +#[doc = "data register for injected group"] +pub struct FLT3JDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for injected group"] +pub mod flt3jdatar; +#[doc = "data register for the regular channel"] +pub struct FLT3RDATAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register for the regular channel"] +pub mod flt3rdatar; +#[doc = "analog watchdog high threshold register"] +pub struct FLT3AWHTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog high threshold register"] +pub mod flt3awhtr; +#[doc = "analog watchdog low threshold register"] +pub struct FLT3AWLTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog low threshold register"] +pub mod flt3awltr; +#[doc = "analog watchdog status register"] +pub struct FLT3AWSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog status register"] +pub mod flt3awsr; +#[doc = "analog watchdog clear flag register"] +pub struct FLT3AWCFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "analog watchdog clear flag register"] +pub mod flt3awcfr; +#[doc = "Extremes detector maximum register"] +pub struct FLT3EXMAX { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector maximum register"] +pub mod flt3exmax; +#[doc = "Extremes detector minimum register"] +pub struct FLT3EXMIN { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Extremes detector minimum register"] +pub mod flt3exmin; +#[doc = "conversion timer register"] +pub struct FLT3CNVTIMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "conversion timer register"] +pub mod flt3cnvtimr; diff --git a/src/dma2/hifcr/mod.rs b/src/dma2/hifcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2c8b4b8b23031c2f50bd066f7e4ee45975e3f9bc --- /dev/null +++ b/src/dma2/hifcr/mod.rs @@ -0,0 +1,589 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::HIFCR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CTCIF7W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF7W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF7W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF7W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF7W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF6W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF6W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF6W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF6W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF6W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF5W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF5W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF5W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF5W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF5W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF4W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF4W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF4W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF4W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF4W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 27 - Stream x clear transfer complete interrupt flag (x = 7..4)"] + #[inline] + pub fn ctcif7(&mut self) -> _CTCIF7W { + _CTCIF7W { w: self } + } + #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 7..4)"] + #[inline] + pub fn chtif7(&mut self) -> _CHTIF7W { + _CHTIF7W { w: self } + } + #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 7..4)"] + #[inline] + pub fn cteif7(&mut self) -> _CTEIF7W { + _CTEIF7W { w: self } + } + #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 7..4)"] + #[inline] + pub fn cdmeif7(&mut self) -> _CDMEIF7W { + _CDMEIF7W { w: self } + } + #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 7..4)"] + #[inline] + pub fn cfeif7(&mut self) -> _CFEIF7W { + _CFEIF7W { w: self } + } + #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 7..4)"] + #[inline] + pub fn ctcif6(&mut self) -> _CTCIF6W { + _CTCIF6W { w: self } + } + #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 7..4)"] + #[inline] + pub fn chtif6(&mut self) -> _CHTIF6W { + _CHTIF6W { w: self } + } + #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 7..4)"] + #[inline] + pub fn cteif6(&mut self) -> _CTEIF6W { + _CTEIF6W { w: self } + } + #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 7..4)"] + #[inline] + pub fn cdmeif6(&mut self) -> _CDMEIF6W { + _CDMEIF6W { w: self } + } + #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 7..4)"] + #[inline] + pub fn cfeif6(&mut self) -> _CFEIF6W { + _CFEIF6W { w: self } + } + #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 7..4)"] + #[inline] + pub fn ctcif5(&mut self) -> _CTCIF5W { + _CTCIF5W { w: self } + } + #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 7..4)"] + #[inline] + pub fn chtif5(&mut self) -> _CHTIF5W { + _CHTIF5W { w: self } + } + #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 7..4)"] + #[inline] + pub fn cteif5(&mut self) -> _CTEIF5W { + _CTEIF5W { w: self } + } + #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 7..4)"] + #[inline] + pub fn cdmeif5(&mut self) -> _CDMEIF5W { + _CDMEIF5W { w: self } + } + #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 7..4)"] + #[inline] + pub fn cfeif5(&mut self) -> _CFEIF5W { + _CFEIF5W { w: self } + } + #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 7..4)"] + #[inline] + pub fn ctcif4(&mut self) -> _CTCIF4W { + _CTCIF4W { w: self } + } + #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 7..4)"] + #[inline] + pub fn chtif4(&mut self) -> _CHTIF4W { + _CHTIF4W { w: self } + } + #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 7..4)"] + #[inline] + pub fn cteif4(&mut self) -> _CTEIF4W { + _CTEIF4W { w: self } + } + #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 7..4)"] + #[inline] + pub fn cdmeif4(&mut self) -> _CDMEIF4W { + _CDMEIF4W { w: self } + } + #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 7..4)"] + #[inline] + pub fn cfeif4(&mut self) -> _CFEIF4W { + _CFEIF4W { w: self } + } +} diff --git a/src/dma2/hisr/mod.rs b/src/dma2/hisr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e28ca6ddbecfa43dc203e52f3917e1f08694918 --- /dev/null +++ b/src/dma2/hisr/mod.rs @@ -0,0 +1,640 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::HISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct TCIF7R { + bits: bool, +} +impl TCIF7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF7R { + bits: bool, +} +impl HTIF7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF7R { + bits: bool, +} +impl TEIF7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF7R { + bits: bool, +} +impl DMEIF7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF7R { + bits: bool, +} +impl FEIF7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF6R { + bits: bool, +} +impl TCIF6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF6R { + bits: bool, +} +impl HTIF6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF6R { + bits: bool, +} +impl TEIF6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF6R { + bits: bool, +} +impl DMEIF6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF6R { + bits: bool, +} +impl FEIF6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF5R { + bits: bool, +} +impl TCIF5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF5R { + bits: bool, +} +impl HTIF5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF5R { + bits: bool, +} +impl TEIF5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF5R { + bits: bool, +} +impl DMEIF5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF5R { + bits: bool, +} +impl FEIF5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF4R { + bits: bool, +} +impl TCIF4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF4R { + bits: bool, +} +impl HTIF4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF4R { + bits: bool, +} +impl TEIF4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF4R { + bits: bool, +} +impl DMEIF4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF4R { + bits: bool, +} +impl FEIF4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 27 - Stream x transfer complete interrupt flag (x=7..4)"] + #[inline] + pub fn tcif7(&self) -> TCIF7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF7R { bits } + } + #[doc = "Bit 26 - Stream x half transfer interrupt flag (x=7..4)"] + #[inline] + pub fn htif7(&self) -> HTIF7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF7R { bits } + } + #[doc = "Bit 25 - Stream x transfer error interrupt flag (x=7..4)"] + #[inline] + pub fn teif7(&self) -> TEIF7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF7R { bits } + } + #[doc = "Bit 24 - Stream x direct mode error interrupt flag (x=7..4)"] + #[inline] + pub fn dmeif7(&self) -> DMEIF7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF7R { bits } + } + #[doc = "Bit 22 - Stream x FIFO error interrupt flag (x=7..4)"] + #[inline] + pub fn feif7(&self) -> FEIF7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF7R { bits } + } + #[doc = "Bit 21 - Stream x transfer complete interrupt flag (x=7..4)"] + #[inline] + pub fn tcif6(&self) -> TCIF6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF6R { bits } + } + #[doc = "Bit 20 - Stream x half transfer interrupt flag (x=7..4)"] + #[inline] + pub fn htif6(&self) -> HTIF6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF6R { bits } + } + #[doc = "Bit 19 - Stream x transfer error interrupt flag (x=7..4)"] + #[inline] + pub fn teif6(&self) -> TEIF6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF6R { bits } + } + #[doc = "Bit 18 - Stream x direct mode error interrupt flag (x=7..4)"] + #[inline] + pub fn dmeif6(&self) -> DMEIF6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF6R { bits } + } + #[doc = "Bit 16 - Stream x FIFO error interrupt flag (x=7..4)"] + #[inline] + pub fn feif6(&self) -> FEIF6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF6R { bits } + } + #[doc = "Bit 11 - Stream x transfer complete interrupt flag (x=7..4)"] + #[inline] + pub fn tcif5(&self) -> TCIF5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF5R { bits } + } + #[doc = "Bit 10 - Stream x half transfer interrupt flag (x=7..4)"] + #[inline] + pub fn htif5(&self) -> HTIF5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF5R { bits } + } + #[doc = "Bit 9 - Stream x transfer error interrupt flag (x=7..4)"] + #[inline] + pub fn teif5(&self) -> TEIF5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF5R { bits } + } + #[doc = "Bit 8 - Stream x direct mode error interrupt flag (x=7..4)"] + #[inline] + pub fn dmeif5(&self) -> DMEIF5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF5R { bits } + } + #[doc = "Bit 6 - Stream x FIFO error interrupt flag (x=7..4)"] + #[inline] + pub fn feif5(&self) -> FEIF5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF5R { bits } + } + #[doc = "Bit 5 - Stream x transfer complete interrupt flag (x=7..4)"] + #[inline] + pub fn tcif4(&self) -> TCIF4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF4R { bits } + } + #[doc = "Bit 4 - Stream x half transfer interrupt flag (x=7..4)"] + #[inline] + pub fn htif4(&self) -> HTIF4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF4R { bits } + } + #[doc = "Bit 3 - Stream x transfer error interrupt flag (x=7..4)"] + #[inline] + pub fn teif4(&self) -> TEIF4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF4R { bits } + } + #[doc = "Bit 2 - Stream x direct mode error interrupt flag (x=7..4)"] + #[inline] + pub fn dmeif4(&self) -> DMEIF4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF4R { bits } + } + #[doc = "Bit 0 - Stream x FIFO error interrupt flag (x=7..4)"] + #[inline] + pub fn feif4(&self) -> FEIF4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF4R { bits } + } +} diff --git a/src/dma2/lifcr/mod.rs b/src/dma2/lifcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7fb826ff1024f3b444e0516e3caf5c024a816939 --- /dev/null +++ b/src/dma2/lifcr/mod.rs @@ -0,0 +1,589 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LIFCR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CTCIF3W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF3W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF3W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF3W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF3W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF2W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF2W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF2W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF2W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF2W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF1W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF1W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF1W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF1W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF1W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCIF0W<'a> { + w: &'a mut W, +} +impl<'a> _CTCIF0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHTIF0W<'a> { + w: &'a mut W, +} +impl<'a> _CHTIF0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEIF0W<'a> { + w: &'a mut W, +} +impl<'a> _CTEIF0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CDMEIF0W<'a> { + w: &'a mut W, +} +impl<'a> _CDMEIF0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CFEIF0W<'a> { + w: &'a mut W, +} +impl<'a> _CFEIF0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 27 - Stream x clear transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn ctcif3(&mut self) -> _CTCIF3W { + _CTCIF3W { w: self } + } + #[doc = "Bit 26 - Stream x clear half transfer interrupt flag (x = 3..0)"] + #[inline] + pub fn chtif3(&mut self) -> _CHTIF3W { + _CHTIF3W { w: self } + } + #[doc = "Bit 25 - Stream x clear transfer error interrupt flag (x = 3..0)"] + #[inline] + pub fn cteif3(&mut self) -> _CTEIF3W { + _CTEIF3W { w: self } + } + #[doc = "Bit 24 - Stream x clear direct mode error interrupt flag (x = 3..0)"] + #[inline] + pub fn cdmeif3(&mut self) -> _CDMEIF3W { + _CDMEIF3W { w: self } + } + #[doc = "Bit 22 - Stream x clear FIFO error interrupt flag (x = 3..0)"] + #[inline] + pub fn cfeif3(&mut self) -> _CFEIF3W { + _CFEIF3W { w: self } + } + #[doc = "Bit 21 - Stream x clear transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn ctcif2(&mut self) -> _CTCIF2W { + _CTCIF2W { w: self } + } + #[doc = "Bit 20 - Stream x clear half transfer interrupt flag (x = 3..0)"] + #[inline] + pub fn chtif2(&mut self) -> _CHTIF2W { + _CHTIF2W { w: self } + } + #[doc = "Bit 19 - Stream x clear transfer error interrupt flag (x = 3..0)"] + #[inline] + pub fn cteif2(&mut self) -> _CTEIF2W { + _CTEIF2W { w: self } + } + #[doc = "Bit 18 - Stream x clear direct mode error interrupt flag (x = 3..0)"] + #[inline] + pub fn cdmeif2(&mut self) -> _CDMEIF2W { + _CDMEIF2W { w: self } + } + #[doc = "Bit 16 - Stream x clear FIFO error interrupt flag (x = 3..0)"] + #[inline] + pub fn cfeif2(&mut self) -> _CFEIF2W { + _CFEIF2W { w: self } + } + #[doc = "Bit 11 - Stream x clear transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn ctcif1(&mut self) -> _CTCIF1W { + _CTCIF1W { w: self } + } + #[doc = "Bit 10 - Stream x clear half transfer interrupt flag (x = 3..0)"] + #[inline] + pub fn chtif1(&mut self) -> _CHTIF1W { + _CHTIF1W { w: self } + } + #[doc = "Bit 9 - Stream x clear transfer error interrupt flag (x = 3..0)"] + #[inline] + pub fn cteif1(&mut self) -> _CTEIF1W { + _CTEIF1W { w: self } + } + #[doc = "Bit 8 - Stream x clear direct mode error interrupt flag (x = 3..0)"] + #[inline] + pub fn cdmeif1(&mut self) -> _CDMEIF1W { + _CDMEIF1W { w: self } + } + #[doc = "Bit 6 - Stream x clear FIFO error interrupt flag (x = 3..0)"] + #[inline] + pub fn cfeif1(&mut self) -> _CFEIF1W { + _CFEIF1W { w: self } + } + #[doc = "Bit 5 - Stream x clear transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn ctcif0(&mut self) -> _CTCIF0W { + _CTCIF0W { w: self } + } + #[doc = "Bit 4 - Stream x clear half transfer interrupt flag (x = 3..0)"] + #[inline] + pub fn chtif0(&mut self) -> _CHTIF0W { + _CHTIF0W { w: self } + } + #[doc = "Bit 3 - Stream x clear transfer error interrupt flag (x = 3..0)"] + #[inline] + pub fn cteif0(&mut self) -> _CTEIF0W { + _CTEIF0W { w: self } + } + #[doc = "Bit 2 - Stream x clear direct mode error interrupt flag (x = 3..0)"] + #[inline] + pub fn cdmeif0(&mut self) -> _CDMEIF0W { + _CDMEIF0W { w: self } + } + #[doc = "Bit 0 - Stream x clear FIFO error interrupt flag (x = 3..0)"] + #[inline] + pub fn cfeif0(&mut self) -> _CFEIF0W { + _CFEIF0W { w: self } + } +} diff --git a/src/dma2/lisr/mod.rs b/src/dma2/lisr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0d7e448b93739dee63242f7152fdaf8120d5cea6 --- /dev/null +++ b/src/dma2/lisr/mod.rs @@ -0,0 +1,640 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::LISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct TCIF3R { + bits: bool, +} +impl TCIF3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF3R { + bits: bool, +} +impl HTIF3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF3R { + bits: bool, +} +impl TEIF3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF3R { + bits: bool, +} +impl DMEIF3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF3R { + bits: bool, +} +impl FEIF3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF2R { + bits: bool, +} +impl TCIF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF2R { + bits: bool, +} +impl HTIF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF2R { + bits: bool, +} +impl TEIF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF2R { + bits: bool, +} +impl DMEIF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF2R { + bits: bool, +} +impl FEIF2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF1R { + bits: bool, +} +impl TCIF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF1R { + bits: bool, +} +impl HTIF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF1R { + bits: bool, +} +impl TEIF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF1R { + bits: bool, +} +impl DMEIF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF1R { + bits: bool, +} +impl FEIF1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIF0R { + bits: bool, +} +impl TCIF0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIF0R { + bits: bool, +} +impl HTIF0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIF0R { + bits: bool, +} +impl TEIF0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIF0R { + bits: bool, +} +impl DMEIF0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FEIF0R { + bits: bool, +} +impl FEIF0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 27 - Stream x transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn tcif3(&self) -> TCIF3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF3R { bits } + } + #[doc = "Bit 26 - Stream x half transfer interrupt flag (x=3..0)"] + #[inline] + pub fn htif3(&self) -> HTIF3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF3R { bits } + } + #[doc = "Bit 25 - Stream x transfer error interrupt flag (x=3..0)"] + #[inline] + pub fn teif3(&self) -> TEIF3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF3R { bits } + } + #[doc = "Bit 24 - Stream x direct mode error interrupt flag (x=3..0)"] + #[inline] + pub fn dmeif3(&self) -> DMEIF3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF3R { bits } + } + #[doc = "Bit 22 - Stream x FIFO error interrupt flag (x=3..0)"] + #[inline] + pub fn feif3(&self) -> FEIF3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF3R { bits } + } + #[doc = "Bit 21 - Stream x transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn tcif2(&self) -> TCIF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF2R { bits } + } + #[doc = "Bit 20 - Stream x half transfer interrupt flag (x=3..0)"] + #[inline] + pub fn htif2(&self) -> HTIF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF2R { bits } + } + #[doc = "Bit 19 - Stream x transfer error interrupt flag (x=3..0)"] + #[inline] + pub fn teif2(&self) -> TEIF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF2R { bits } + } + #[doc = "Bit 18 - Stream x direct mode error interrupt flag (x=3..0)"] + #[inline] + pub fn dmeif2(&self) -> DMEIF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF2R { bits } + } + #[doc = "Bit 16 - Stream x FIFO error interrupt flag (x=3..0)"] + #[inline] + pub fn feif2(&self) -> FEIF2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF2R { bits } + } + #[doc = "Bit 11 - Stream x transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn tcif1(&self) -> TCIF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF1R { bits } + } + #[doc = "Bit 10 - Stream x half transfer interrupt flag (x=3..0)"] + #[inline] + pub fn htif1(&self) -> HTIF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF1R { bits } + } + #[doc = "Bit 9 - Stream x transfer error interrupt flag (x=3..0)"] + #[inline] + pub fn teif1(&self) -> TEIF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF1R { bits } + } + #[doc = "Bit 8 - Stream x direct mode error interrupt flag (x=3..0)"] + #[inline] + pub fn dmeif1(&self) -> DMEIF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF1R { bits } + } + #[doc = "Bit 6 - Stream x FIFO error interrupt flag (x=3..0)"] + #[inline] + pub fn feif1(&self) -> FEIF1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF1R { bits } + } + #[doc = "Bit 5 - Stream x transfer complete interrupt flag (x = 3..0)"] + #[inline] + pub fn tcif0(&self) -> TCIF0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIF0R { bits } + } + #[doc = "Bit 4 - Stream x half transfer interrupt flag (x=3..0)"] + #[inline] + pub fn htif0(&self) -> HTIF0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIF0R { bits } + } + #[doc = "Bit 3 - Stream x transfer error interrupt flag (x=3..0)"] + #[inline] + pub fn teif0(&self) -> TEIF0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIF0R { bits } + } + #[doc = "Bit 2 - Stream x direct mode error interrupt flag (x=3..0)"] + #[inline] + pub fn dmeif0(&self) -> DMEIF0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIF0R { bits } + } + #[doc = "Bit 0 - Stream x FIFO error interrupt flag (x=3..0)"] + #[inline] + pub fn feif0(&self) -> FEIF0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIF0R { bits } + } +} diff --git a/src/dma2/mod.rs b/src/dma2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a5017b39831a13c03e8bce761d563951f8b9ed79 --- /dev/null +++ b/src/dma2/mod.rs @@ -0,0 +1,420 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - low interrupt status register"] + pub lisr: LISR, + #[doc = "0x04 - high interrupt status register"] + pub hisr: HISR, + #[doc = "0x08 - low interrupt flag clear register"] + pub lifcr: LIFCR, + #[doc = "0x0c - high interrupt flag clear register"] + pub hifcr: HIFCR, + #[doc = "0x10 - stream x configuration register"] + pub s0cr: S0CR, + #[doc = "0x14 - stream x number of data register"] + pub s0ndtr: S0NDTR, + #[doc = "0x18 - stream x peripheral address register"] + pub s0par: S0PAR, + #[doc = "0x1c - stream x memory 0 address register"] + pub s0m0ar: S0M0AR, + #[doc = "0x20 - stream x memory 1 address register"] + pub s0m1ar: S0M1AR, + #[doc = "0x24 - stream x FIFO control register"] + pub s0fcr: S0FCR, + #[doc = "0x28 - stream x configuration register"] + pub s1cr: S1CR, + #[doc = "0x2c - stream x number of data register"] + pub s1ndtr: S1NDTR, + #[doc = "0x30 - stream x peripheral address register"] + pub s1par: S1PAR, + #[doc = "0x34 - stream x memory 0 address register"] + pub s1m0ar: S1M0AR, + #[doc = "0x38 - stream x memory 1 address register"] + pub s1m1ar: S1M1AR, + #[doc = "0x3c - stream x FIFO control register"] + pub s1fcr: S1FCR, + #[doc = "0x40 - stream x configuration register"] + pub s2cr: S2CR, + #[doc = "0x44 - stream x number of data register"] + pub s2ndtr: S2NDTR, + #[doc = "0x48 - stream x peripheral address register"] + pub s2par: S2PAR, + #[doc = "0x4c - stream x memory 0 address register"] + pub s2m0ar: S2M0AR, + #[doc = "0x50 - stream x memory 1 address register"] + pub s2m1ar: S2M1AR, + #[doc = "0x54 - stream x FIFO control register"] + pub s2fcr: S2FCR, + #[doc = "0x58 - stream x configuration register"] + pub s3cr: S3CR, + #[doc = "0x5c - stream x number of data register"] + pub s3ndtr: S3NDTR, + #[doc = "0x60 - stream x peripheral address register"] + pub s3par: S3PAR, + #[doc = "0x64 - stream x memory 0 address register"] + pub s3m0ar: S3M0AR, + #[doc = "0x68 - stream x memory 1 address register"] + pub s3m1ar: S3M1AR, + #[doc = "0x6c - stream x FIFO control register"] + pub s3fcr: S3FCR, + #[doc = "0x70 - stream x configuration register"] + pub s4cr: S4CR, + #[doc = "0x74 - stream x number of data register"] + pub s4ndtr: S4NDTR, + #[doc = "0x78 - stream x peripheral address register"] + pub s4par: S4PAR, + #[doc = "0x7c - stream x memory 0 address register"] + pub s4m0ar: S4M0AR, + #[doc = "0x80 - stream x memory 1 address register"] + pub s4m1ar: S4M1AR, + #[doc = "0x84 - stream x FIFO control register"] + pub s4fcr: S4FCR, + #[doc = "0x88 - stream x configuration register"] + pub s5cr: S5CR, + #[doc = "0x8c - stream x number of data register"] + pub s5ndtr: S5NDTR, + #[doc = "0x90 - stream x peripheral address register"] + pub s5par: S5PAR, + #[doc = "0x94 - stream x memory 0 address register"] + pub s5m0ar: S5M0AR, + #[doc = "0x98 - stream x memory 1 address register"] + pub s5m1ar: S5M1AR, + #[doc = "0x9c - stream x FIFO control register"] + pub s5fcr: S5FCR, + #[doc = "0xa0 - stream x configuration register"] + pub s6cr: S6CR, + #[doc = "0xa4 - stream x number of data register"] + pub s6ndtr: S6NDTR, + #[doc = "0xa8 - stream x peripheral address register"] + pub s6par: S6PAR, + #[doc = "0xac - stream x memory 0 address register"] + pub s6m0ar: S6M0AR, + #[doc = "0xb0 - stream x memory 1 address register"] + pub s6m1ar: S6M1AR, + #[doc = "0xb4 - stream x FIFO control register"] + pub s6fcr: S6FCR, + #[doc = "0xb8 - stream x configuration register"] + pub s7cr: S7CR, + #[doc = "0xbc - stream x number of data register"] + pub s7ndtr: S7NDTR, + #[doc = "0xc0 - stream x peripheral address register"] + pub s7par: S7PAR, + #[doc = "0xc4 - stream x memory 0 address register"] + pub s7m0ar: S7M0AR, + #[doc = "0xc8 - stream x memory 1 address register"] + pub s7m1ar: S7M1AR, + #[doc = "0xcc - stream x FIFO control register"] + pub s7fcr: S7FCR, +} +#[doc = "low interrupt status register"] +pub struct LISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "low interrupt status register"] +pub mod lisr; +#[doc = "high interrupt status register"] +pub struct HISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "high interrupt status register"] +pub mod hisr; +#[doc = "low interrupt flag clear register"] +pub struct LIFCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "low interrupt flag clear register"] +pub mod lifcr; +#[doc = "high interrupt flag clear register"] +pub struct HIFCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "high interrupt flag clear register"] +pub mod hifcr; +#[doc = "stream x configuration register"] +pub struct S0CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s0cr; +#[doc = "stream x number of data register"] +pub struct S0NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s0ndtr; +#[doc = "stream x peripheral address register"] +pub struct S0PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s0par; +#[doc = "stream x memory 0 address register"] +pub struct S0M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s0m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S0M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s0m1ar; +#[doc = "stream x FIFO control register"] +pub struct S0FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s0fcr; +#[doc = "stream x configuration register"] +pub struct S1CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s1cr; +#[doc = "stream x number of data register"] +pub struct S1NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s1ndtr; +#[doc = "stream x peripheral address register"] +pub struct S1PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s1par; +#[doc = "stream x memory 0 address register"] +pub struct S1M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s1m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S1M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s1m1ar; +#[doc = "stream x FIFO control register"] +pub struct S1FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s1fcr; +#[doc = "stream x configuration register"] +pub struct S2CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s2cr; +#[doc = "stream x number of data register"] +pub struct S2NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s2ndtr; +#[doc = "stream x peripheral address register"] +pub struct S2PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s2par; +#[doc = "stream x memory 0 address register"] +pub struct S2M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s2m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S2M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s2m1ar; +#[doc = "stream x FIFO control register"] +pub struct S2FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s2fcr; +#[doc = "stream x configuration register"] +pub struct S3CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s3cr; +#[doc = "stream x number of data register"] +pub struct S3NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s3ndtr; +#[doc = "stream x peripheral address register"] +pub struct S3PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s3par; +#[doc = "stream x memory 0 address register"] +pub struct S3M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s3m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S3M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s3m1ar; +#[doc = "stream x FIFO control register"] +pub struct S3FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s3fcr; +#[doc = "stream x configuration register"] +pub struct S4CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s4cr; +#[doc = "stream x number of data register"] +pub struct S4NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s4ndtr; +#[doc = "stream x peripheral address register"] +pub struct S4PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s4par; +#[doc = "stream x memory 0 address register"] +pub struct S4M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s4m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S4M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s4m1ar; +#[doc = "stream x FIFO control register"] +pub struct S4FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s4fcr; +#[doc = "stream x configuration register"] +pub struct S5CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s5cr; +#[doc = "stream x number of data register"] +pub struct S5NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s5ndtr; +#[doc = "stream x peripheral address register"] +pub struct S5PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s5par; +#[doc = "stream x memory 0 address register"] +pub struct S5M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s5m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S5M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s5m1ar; +#[doc = "stream x FIFO control register"] +pub struct S5FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s5fcr; +#[doc = "stream x configuration register"] +pub struct S6CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s6cr; +#[doc = "stream x number of data register"] +pub struct S6NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s6ndtr; +#[doc = "stream x peripheral address register"] +pub struct S6PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s6par; +#[doc = "stream x memory 0 address register"] +pub struct S6M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s6m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S6M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s6m1ar; +#[doc = "stream x FIFO control register"] +pub struct S6FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s6fcr; +#[doc = "stream x configuration register"] +pub struct S7CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x configuration register"] +pub mod s7cr; +#[doc = "stream x number of data register"] +pub struct S7NDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x number of data register"] +pub mod s7ndtr; +#[doc = "stream x peripheral address register"] +pub struct S7PAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x peripheral address register"] +pub mod s7par; +#[doc = "stream x memory 0 address register"] +pub struct S7M0AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 0 address register"] +pub mod s7m0ar; +#[doc = "stream x memory 1 address register"] +pub struct S7M1AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x memory 1 address register"] +pub mod s7m1ar; +#[doc = "stream x FIFO control register"] +pub struct S7FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "stream x FIFO control register"] +pub mod s7fcr; diff --git a/src/dma2/s0cr/mod.rs b/src/dma2/s0cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9535a070e5edfd0ce0625f4be1b803a99af65da6 --- /dev/null +++ b/src/dma2/s0cr/mod.rs @@ -0,0 +1,1059 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s0fcr/mod.rs b/src/dma2/s0fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..45818e0a339ecc6fa9511603b59d61cf3270867c --- /dev/null +++ b/src/dma2/s0fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s0m0ar/mod.rs b/src/dma2/s0m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c3df66f506d4ebb700266e237a8eee93e08362f3 --- /dev/null +++ b/src/dma2/s0m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s0m1ar/mod.rs b/src/dma2/s0m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..07445a95362ecbfd416ca57a2e9f9f10ae78a921 --- /dev/null +++ b/src/dma2/s0m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s0ndtr/mod.rs b/src/dma2/s0ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2dc776c92bc234774ed56984229257aade316195 --- /dev/null +++ b/src/dma2/s0ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s0par/mod.rs b/src/dma2/s0par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eb44a2f22cdfad82ed722dc91141ba5c695fd82f --- /dev/null +++ b/src/dma2/s0par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S0PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s1cr/mod.rs b/src/dma2/s1cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a99deeafe022643d28b649e088a37888594bc54c --- /dev/null +++ b/src/dma2/s1cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s1fcr/mod.rs b/src/dma2/s1fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c6c52780e8d4271715e19c7f5cc05f5cfe36f03c --- /dev/null +++ b/src/dma2/s1fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s1m0ar/mod.rs b/src/dma2/s1m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..550bec7b387326f2c7ae4c034f67cf8588463cb9 --- /dev/null +++ b/src/dma2/s1m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s1m1ar/mod.rs b/src/dma2/s1m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6e8ec0cc850823e2f056e50ebb1c6b711bf163ca --- /dev/null +++ b/src/dma2/s1m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s1ndtr/mod.rs b/src/dma2/s1ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5d8729af5ef536e64fe61152dd332cc19ee8d84e --- /dev/null +++ b/src/dma2/s1ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s1par/mod.rs b/src/dma2/s1par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bd356f4a2bf90f96be137582fc32d33382cbc71a --- /dev/null +++ b/src/dma2/s1par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S1PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s2cr/mod.rs b/src/dma2/s2cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ded5c0ca2dd26060860cc1d5f1e2e0ab1a681fa7 --- /dev/null +++ b/src/dma2/s2cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s2fcr/mod.rs b/src/dma2/s2fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6d2aa47a979069a6dc30a7a02a85cb7c4660c0e2 --- /dev/null +++ b/src/dma2/s2fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s2m0ar/mod.rs b/src/dma2/s2m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..edd240cf768eadb656f2917827bd1826353f21bd --- /dev/null +++ b/src/dma2/s2m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s2m1ar/mod.rs b/src/dma2/s2m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..78dfb0c205d76901054c403276b6431d43d23277 --- /dev/null +++ b/src/dma2/s2m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s2ndtr/mod.rs b/src/dma2/s2ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5e04bd78f3c1d2429763e818b4e06fe613e092ab --- /dev/null +++ b/src/dma2/s2ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s2par/mod.rs b/src/dma2/s2par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e9b0d76d4f5e4ce32688ac955a0ea47a33c0e79c --- /dev/null +++ b/src/dma2/s2par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S2PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s3cr/mod.rs b/src/dma2/s3cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b90be2d379c7bf43798171bcbffa4fead9913b2 --- /dev/null +++ b/src/dma2/s3cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s3fcr/mod.rs b/src/dma2/s3fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1e4bf77f23030c2ec0c88ad895bc9aca0d8532aa --- /dev/null +++ b/src/dma2/s3fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s3m0ar/mod.rs b/src/dma2/s3m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d780be11a71404e9aef98d0cb7c5d7e1e3d4823f --- /dev/null +++ b/src/dma2/s3m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s3m1ar/mod.rs b/src/dma2/s3m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..246a10404f2abcd0a329d4325f0d22e7d71418de --- /dev/null +++ b/src/dma2/s3m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s3ndtr/mod.rs b/src/dma2/s3ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..216ec09f2080d597c3c2a13e23470b40084c9274 --- /dev/null +++ b/src/dma2/s3ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s3par/mod.rs b/src/dma2/s3par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..597f0630f2c5bd9221ce8ce035e0dafcc5b868c1 --- /dev/null +++ b/src/dma2/s3par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S3PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s4cr/mod.rs b/src/dma2/s4cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3ae4f89446dd6bb62217ead76a37b06049d86415 --- /dev/null +++ b/src/dma2/s4cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s4fcr/mod.rs b/src/dma2/s4fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dd65c38a34a7cbfbc8dcc98d840b56499ee39733 --- /dev/null +++ b/src/dma2/s4fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s4m0ar/mod.rs b/src/dma2/s4m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ae252f4101073753b92ba27cbe1ae36efd2c3b2b --- /dev/null +++ b/src/dma2/s4m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s4m1ar/mod.rs b/src/dma2/s4m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cd587b0ee458674de8ec4f902ab0bdae63750c32 --- /dev/null +++ b/src/dma2/s4m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s4ndtr/mod.rs b/src/dma2/s4ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bff4dd7c292c5b321f3b5bdc6c30f1a0f719e11f --- /dev/null +++ b/src/dma2/s4ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s4par/mod.rs b/src/dma2/s4par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3900f857af7d92e76448ee10286e625c03077f09 --- /dev/null +++ b/src/dma2/s4par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S4PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s5cr/mod.rs b/src/dma2/s5cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7c5def831005cd9019680f44963ca1dd8f5b2bcd --- /dev/null +++ b/src/dma2/s5cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s5fcr/mod.rs b/src/dma2/s5fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..31ee1b4a5b50cb8f6c3fd8967d9e9d0f4df122f6 --- /dev/null +++ b/src/dma2/s5fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s5m0ar/mod.rs b/src/dma2/s5m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..68a1c45a277ecfa889b82df6dd3cdf90ca6afb7e --- /dev/null +++ b/src/dma2/s5m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s5m1ar/mod.rs b/src/dma2/s5m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d6c2dced6177b2bce4706a392f4339e72e79a9ee --- /dev/null +++ b/src/dma2/s5m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s5ndtr/mod.rs b/src/dma2/s5ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0bdb5f0d4148f273907bc1724a2d8818014e3fdf --- /dev/null +++ b/src/dma2/s5ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s5par/mod.rs b/src/dma2/s5par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b78ae8f62f3fae6fd2d0a0719188ee096379583 --- /dev/null +++ b/src/dma2/s5par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S5PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s6cr/mod.rs b/src/dma2/s6cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..adbffb7e7b4d2fdeede179883544532b6e255005 --- /dev/null +++ b/src/dma2/s6cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s6fcr/mod.rs b/src/dma2/s6fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ff7bbc2c6de18e4d28c1f0bfbaf191dfabe0e12e --- /dev/null +++ b/src/dma2/s6fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s6m0ar/mod.rs b/src/dma2/s6m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..662c80f859082f99ad20facecd976f9406aded31 --- /dev/null +++ b/src/dma2/s6m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s6m1ar/mod.rs b/src/dma2/s6m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7818aa0787b5dc84369d11efc250f72d215b15ce --- /dev/null +++ b/src/dma2/s6m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s6ndtr/mod.rs b/src/dma2/s6ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7dcbf6949ee87f4a080c8607df92f72096ff76ed --- /dev/null +++ b/src/dma2/s6ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s6par/mod.rs b/src/dma2/s6par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c81d51f6d4f340cc1c93f433ec3b29fd32299c96 --- /dev/null +++ b/src/dma2/s6par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S6PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/dma2/s7cr/mod.rs b/src/dma2/s7cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fc55b393a12dcabb5428f7d31f1bdca6348aa0a5 --- /dev/null +++ b/src/dma2/s7cr/mod.rs @@ -0,0 +1,1118 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CHSELR { + bits: u8, +} +impl CHSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MBURSTR { + bits: u8, +} +impl MBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PBURSTR { + bits: u8, +} +impl PBURSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTR { + bits: bool, +} +impl CTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBMR { + bits: bool, +} +impl DBMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLR { + bits: u8, +} +impl PLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PINCOSR { + bits: bool, +} +impl PINCOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSIZER { + bits: u8, +} +impl MSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MINCR { + bits: bool, +} +impl MINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PINCR { + bits: bool, +} +impl PINCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIRCR { + bits: bool, +} +impl CIRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: u8, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFCTRLR { + bits: bool, +} +impl PFCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTIER { + bits: bool, +} +impl HTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMEIER { + bits: bool, +} +impl DMEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CHSELW<'a> { + w: &'a mut W, +} +impl<'a> _CHSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _MBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBURSTW<'a> { + w: &'a mut W, +} +impl<'a> _PBURSTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTW<'a> { + w: &'a mut W, +} +impl<'a> _CTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBMW<'a> { + w: &'a mut W, +} +impl<'a> _DBMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLW<'a> { + w: &'a mut W, +} +impl<'a> _PLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCOSW<'a> { + w: &'a mut W, +} +impl<'a> _PINCOSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _MSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MINCW<'a> { + w: &'a mut W, +} +impl<'a> _MINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PINCW<'a> { + w: &'a mut W, +} +impl<'a> _PINCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIRCW<'a> { + w: &'a mut W, +} +impl<'a> _CIRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PFCTRLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTIEW<'a> { + w: &'a mut W, +} +impl<'a> _HTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMEIEW<'a> { + w: &'a mut W, +} +impl<'a> _DMEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&self) -> CHSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CHSELR { bits } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&self) -> MBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MBURSTR { bits } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&self) -> PBURSTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PBURSTR { bits } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&self) -> CTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTR { bits } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&self) -> DBMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBMR { bits } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&self) -> PLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLR { bits } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&self) -> PINCOSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCOSR { bits } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&self) -> MSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MSIZER { bits } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&self) -> MINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MINCR { bits } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&self) -> PINCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PINCR { bits } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&self) -> CIRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIRCR { bits } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIRR { bits } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&self) -> PFCTRLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PFCTRLR { bits } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&self) -> HTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HTIER { bits } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&self) -> DMEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMEIER { bits } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 25:27 - Channel selection"] + #[inline] + pub fn chsel(&mut self) -> _CHSELW { + _CHSELW { w: self } + } + #[doc = "Bits 23:24 - Memory burst transfer configuration"] + #[inline] + pub fn mburst(&mut self) -> _MBURSTW { + _MBURSTW { w: self } + } + #[doc = "Bits 21:22 - Peripheral burst transfer configuration"] + #[inline] + pub fn pburst(&mut self) -> _PBURSTW { + _PBURSTW { w: self } + } + #[doc = "Bit 20 - ACK"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 19 - Current target (only in double buffer mode)"] + #[inline] + pub fn ct(&mut self) -> _CTW { + _CTW { w: self } + } + #[doc = "Bit 18 - Double buffer mode"] + #[inline] + pub fn dbm(&mut self) -> _DBMW { + _DBMW { w: self } + } + #[doc = "Bits 16:17 - Priority level"] + #[inline] + pub fn pl(&mut self) -> _PLW { + _PLW { w: self } + } + #[doc = "Bit 15 - Peripheral increment offset size"] + #[inline] + pub fn pincos(&mut self) -> _PINCOSW { + _PINCOSW { w: self } + } + #[doc = "Bits 13:14 - Memory data size"] + #[inline] + pub fn msize(&mut self) -> _MSIZEW { + _MSIZEW { w: self } + } + #[doc = "Bits 11:12 - Peripheral data size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 10 - Memory increment mode"] + #[inline] + pub fn minc(&mut self) -> _MINCW { + _MINCW { w: self } + } + #[doc = "Bit 9 - Peripheral increment mode"] + #[inline] + pub fn pinc(&mut self) -> _PINCW { + _PINCW { w: self } + } + #[doc = "Bit 8 - Circular mode"] + #[inline] + pub fn circ(&mut self) -> _CIRCW { + _CIRCW { w: self } + } + #[doc = "Bits 6:7 - Data transfer direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 5 - Peripheral flow controller"] + #[inline] + pub fn pfctrl(&mut self) -> _PFCTRLW { + _PFCTRLW { w: self } + } + #[doc = "Bit 4 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 3 - Half transfer interrupt enable"] + #[inline] + pub fn htie(&mut self) -> _HTIEW { + _HTIEW { w: self } + } + #[doc = "Bit 2 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bit 1 - Direct mode error interrupt enable"] + #[inline] + pub fn dmeie(&mut self) -> _DMEIEW { + _DMEIEW { w: self } + } + #[doc = "Bit 0 - Stream enable / flag stream ready when read low"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/dma2/s7fcr/mod.rs b/src/dma2/s7fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ff5df0c13c96c5492a8e280659b9761bad38c0e8 --- /dev/null +++ b/src/dma2/s7fcr/mod.rs @@ -0,0 +1,244 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEIER { + bits: bool, +} +impl FEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSR { + bits: u8, +} +impl FSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMDISR { + bits: bool, +} +impl DMDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FEIEW<'a> { + w: &'a mut W, +} +impl<'a> _FEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMDISW<'a> { + w: &'a mut W, +} +impl<'a> _DMDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&self) -> FEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEIER { bits } + } + #[doc = "Bits 3:5 - FIFO status"] + #[inline] + pub fn fs(&self) -> FSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSR { bits } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&self) -> DMDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMDISR { bits } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - FIFO error interrupt enable"] + #[inline] + pub fn feie(&mut self) -> _FEIEW { + _FEIEW { w: self } + } + #[doc = "Bit 2 - Direct mode disable"] + #[inline] + pub fn dmdis(&mut self) -> _DMDISW { + _DMDISW { w: self } + } + #[doc = "Bits 0:1 - FIFO threshold selection"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/dma2/s7m0ar/mod.rs b/src/dma2/s7m0ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d7ef95ae34996aa9622868ae5b5d8e4008901eb --- /dev/null +++ b/src/dma2/s7m0ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7M0AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M0AR { + bits: u32, +} +impl M0AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M0AW<'a> { + w: &'a mut W, +} +impl<'a> _M0AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&self) -> M0AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M0AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 0 address"] + #[inline] + pub fn m0a(&mut self) -> _M0AW { + _M0AW { w: self } + } +} diff --git a/src/dma2/s7m1ar/mod.rs b/src/dma2/s7m1ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bda0eac508285886f252b3c9c5b6f0b3bbb9522c --- /dev/null +++ b/src/dma2/s7m1ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7M1AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct M1AR { + bits: u32, +} +impl M1AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _M1AW<'a> { + w: &'a mut W, +} +impl<'a> _M1AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&self) -> M1AR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + M1AR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Memory 1 address (used in case of Double buffer mode)"] + #[inline] + pub fn m1a(&mut self) -> _M1AW { + _M1AW { w: self } + } +} diff --git a/src/dma2/s7ndtr/mod.rs b/src/dma2/s7ndtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..13b75c287e87227b8dcf39cc6dd7817069fe4516 --- /dev/null +++ b/src/dma2/s7ndtr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7NDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NDTR { + bits: u16, +} +impl NDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NDTW<'a> { + w: &'a mut W, +} +impl<'a> _NDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&self) -> NDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Number of data items to transfer"] + #[inline] + pub fn ndt(&mut self) -> _NDTW { + _NDTW { w: self } + } +} diff --git a/src/dma2/s7par/mod.rs b/src/dma2/s7par/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..954504e2be15c93218f8da8f7ef4c20708d611e5 --- /dev/null +++ b/src/dma2/s7par/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::S7PAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PAR { + bits: u32, +} +impl PAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PAW<'a> { + w: &'a mut W, +} +impl<'a> _PAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&self) -> PAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Peripheral address"] + #[inline] + pub fn pa(&mut self) -> _PAW { + _PAW { w: self } + } +} diff --git a/src/exti/emr/mod.rs b/src/exti/emr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cf6d9e2d8f5ef05e661a89a0011f31f8155cdf5d --- /dev/null +++ b/src/exti/emr/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EMR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MR0R { + bits: bool, +} +impl MR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR1R { + bits: bool, +} +impl MR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR2R { + bits: bool, +} +impl MR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR3R { + bits: bool, +} +impl MR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR4R { + bits: bool, +} +impl MR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR5R { + bits: bool, +} +impl MR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR6R { + bits: bool, +} +impl MR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR7R { + bits: bool, +} +impl MR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR8R { + bits: bool, +} +impl MR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR9R { + bits: bool, +} +impl MR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR10R { + bits: bool, +} +impl MR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR11R { + bits: bool, +} +impl MR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR12R { + bits: bool, +} +impl MR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR13R { + bits: bool, +} +impl MR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR14R { + bits: bool, +} +impl MR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR15R { + bits: bool, +} +impl MR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR16R { + bits: bool, +} +impl MR16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR17R { + bits: bool, +} +impl MR17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR18R { + bits: bool, +} +impl MR18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR19R { + bits: bool, +} +impl MR19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR20R { + bits: bool, +} +impl MR20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR21R { + bits: bool, +} +impl MR21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR22R { + bits: bool, +} +impl MR22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MR0W<'a> { + w: &'a mut W, +} +impl<'a> _MR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR1W<'a> { + w: &'a mut W, +} +impl<'a> _MR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR2W<'a> { + w: &'a mut W, +} +impl<'a> _MR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR3W<'a> { + w: &'a mut W, +} +impl<'a> _MR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR4W<'a> { + w: &'a mut W, +} +impl<'a> _MR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR5W<'a> { + w: &'a mut W, +} +impl<'a> _MR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR6W<'a> { + w: &'a mut W, +} +impl<'a> _MR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR7W<'a> { + w: &'a mut W, +} +impl<'a> _MR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR8W<'a> { + w: &'a mut W, +} +impl<'a> _MR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR9W<'a> { + w: &'a mut W, +} +impl<'a> _MR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR10W<'a> { + w: &'a mut W, +} +impl<'a> _MR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR11W<'a> { + w: &'a mut W, +} +impl<'a> _MR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR12W<'a> { + w: &'a mut W, +} +impl<'a> _MR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR13W<'a> { + w: &'a mut W, +} +impl<'a> _MR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR14W<'a> { + w: &'a mut W, +} +impl<'a> _MR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR15W<'a> { + w: &'a mut W, +} +impl<'a> _MR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR16W<'a> { + w: &'a mut W, +} +impl<'a> _MR16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR17W<'a> { + w: &'a mut W, +} +impl<'a> _MR17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR18W<'a> { + w: &'a mut W, +} +impl<'a> _MR18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR19W<'a> { + w: &'a mut W, +} +impl<'a> _MR19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR20W<'a> { + w: &'a mut W, +} +impl<'a> _MR20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR21W<'a> { + w: &'a mut W, +} +impl<'a> _MR21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR22W<'a> { + w: &'a mut W, +} +impl<'a> _MR22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Event Mask on line 0"] + #[inline] + pub fn mr0(&self) -> MR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR0R { bits } + } + #[doc = "Bit 1 - Event Mask on line 1"] + #[inline] + pub fn mr1(&self) -> MR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR1R { bits } + } + #[doc = "Bit 2 - Event Mask on line 2"] + #[inline] + pub fn mr2(&self) -> MR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR2R { bits } + } + #[doc = "Bit 3 - Event Mask on line 3"] + #[inline] + pub fn mr3(&self) -> MR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR3R { bits } + } + #[doc = "Bit 4 - Event Mask on line 4"] + #[inline] + pub fn mr4(&self) -> MR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR4R { bits } + } + #[doc = "Bit 5 - Event Mask on line 5"] + #[inline] + pub fn mr5(&self) -> MR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR5R { bits } + } + #[doc = "Bit 6 - Event Mask on line 6"] + #[inline] + pub fn mr6(&self) -> MR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR6R { bits } + } + #[doc = "Bit 7 - Event Mask on line 7"] + #[inline] + pub fn mr7(&self) -> MR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR7R { bits } + } + #[doc = "Bit 8 - Event Mask on line 8"] + #[inline] + pub fn mr8(&self) -> MR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR8R { bits } + } + #[doc = "Bit 9 - Event Mask on line 9"] + #[inline] + pub fn mr9(&self) -> MR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR9R { bits } + } + #[doc = "Bit 10 - Event Mask on line 10"] + #[inline] + pub fn mr10(&self) -> MR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR10R { bits } + } + #[doc = "Bit 11 - Event Mask on line 11"] + #[inline] + pub fn mr11(&self) -> MR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR11R { bits } + } + #[doc = "Bit 12 - Event Mask on line 12"] + #[inline] + pub fn mr12(&self) -> MR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR12R { bits } + } + #[doc = "Bit 13 - Event Mask on line 13"] + #[inline] + pub fn mr13(&self) -> MR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR13R { bits } + } + #[doc = "Bit 14 - Event Mask on line 14"] + #[inline] + pub fn mr14(&self) -> MR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR14R { bits } + } + #[doc = "Bit 15 - Event Mask on line 15"] + #[inline] + pub fn mr15(&self) -> MR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR15R { bits } + } + #[doc = "Bit 16 - Event Mask on line 16"] + #[inline] + pub fn mr16(&self) -> MR16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR16R { bits } + } + #[doc = "Bit 17 - Event Mask on line 17"] + #[inline] + pub fn mr17(&self) -> MR17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR17R { bits } + } + #[doc = "Bit 18 - Event Mask on line 18"] + #[inline] + pub fn mr18(&self) -> MR18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR18R { bits } + } + #[doc = "Bit 19 - Event Mask on line 19"] + #[inline] + pub fn mr19(&self) -> MR19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR19R { bits } + } + #[doc = "Bit 20 - Event Mask on line 20"] + #[inline] + pub fn mr20(&self) -> MR20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR20R { bits } + } + #[doc = "Bit 21 - Event Mask on line 21"] + #[inline] + pub fn mr21(&self) -> MR21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR21R { bits } + } + #[doc = "Bit 22 - Event Mask on line 22"] + #[inline] + pub fn mr22(&self) -> MR22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Event Mask on line 0"] + #[inline] + pub fn mr0(&mut self) -> _MR0W { + _MR0W { w: self } + } + #[doc = "Bit 1 - Event Mask on line 1"] + #[inline] + pub fn mr1(&mut self) -> _MR1W { + _MR1W { w: self } + } + #[doc = "Bit 2 - Event Mask on line 2"] + #[inline] + pub fn mr2(&mut self) -> _MR2W { + _MR2W { w: self } + } + #[doc = "Bit 3 - Event Mask on line 3"] + #[inline] + pub fn mr3(&mut self) -> _MR3W { + _MR3W { w: self } + } + #[doc = "Bit 4 - Event Mask on line 4"] + #[inline] + pub fn mr4(&mut self) -> _MR4W { + _MR4W { w: self } + } + #[doc = "Bit 5 - Event Mask on line 5"] + #[inline] + pub fn mr5(&mut self) -> _MR5W { + _MR5W { w: self } + } + #[doc = "Bit 6 - Event Mask on line 6"] + #[inline] + pub fn mr6(&mut self) -> _MR6W { + _MR6W { w: self } + } + #[doc = "Bit 7 - Event Mask on line 7"] + #[inline] + pub fn mr7(&mut self) -> _MR7W { + _MR7W { w: self } + } + #[doc = "Bit 8 - Event Mask on line 8"] + #[inline] + pub fn mr8(&mut self) -> _MR8W { + _MR8W { w: self } + } + #[doc = "Bit 9 - Event Mask on line 9"] + #[inline] + pub fn mr9(&mut self) -> _MR9W { + _MR9W { w: self } + } + #[doc = "Bit 10 - Event Mask on line 10"] + #[inline] + pub fn mr10(&mut self) -> _MR10W { + _MR10W { w: self } + } + #[doc = "Bit 11 - Event Mask on line 11"] + #[inline] + pub fn mr11(&mut self) -> _MR11W { + _MR11W { w: self } + } + #[doc = "Bit 12 - Event Mask on line 12"] + #[inline] + pub fn mr12(&mut self) -> _MR12W { + _MR12W { w: self } + } + #[doc = "Bit 13 - Event Mask on line 13"] + #[inline] + pub fn mr13(&mut self) -> _MR13W { + _MR13W { w: self } + } + #[doc = "Bit 14 - Event Mask on line 14"] + #[inline] + pub fn mr14(&mut self) -> _MR14W { + _MR14W { w: self } + } + #[doc = "Bit 15 - Event Mask on line 15"] + #[inline] + pub fn mr15(&mut self) -> _MR15W { + _MR15W { w: self } + } + #[doc = "Bit 16 - Event Mask on line 16"] + #[inline] + pub fn mr16(&mut self) -> _MR16W { + _MR16W { w: self } + } + #[doc = "Bit 17 - Event Mask on line 17"] + #[inline] + pub fn mr17(&mut self) -> _MR17W { + _MR17W { w: self } + } + #[doc = "Bit 18 - Event Mask on line 18"] + #[inline] + pub fn mr18(&mut self) -> _MR18W { + _MR18W { w: self } + } + #[doc = "Bit 19 - Event Mask on line 19"] + #[inline] + pub fn mr19(&mut self) -> _MR19W { + _MR19W { w: self } + } + #[doc = "Bit 20 - Event Mask on line 20"] + #[inline] + pub fn mr20(&mut self) -> _MR20W { + _MR20W { w: self } + } + #[doc = "Bit 21 - Event Mask on line 21"] + #[inline] + pub fn mr21(&mut self) -> _MR21W { + _MR21W { w: self } + } + #[doc = "Bit 22 - Event Mask on line 22"] + #[inline] + pub fn mr22(&mut self) -> _MR22W { + _MR22W { w: self } + } +} diff --git a/src/exti/ftsr/mod.rs b/src/exti/ftsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6623144092968296dbd6c1df06e5f457cbfa1674 --- /dev/null +++ b/src/exti/ftsr/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FTSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TR0R { + bits: bool, +} +impl TR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR1R { + bits: bool, +} +impl TR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR2R { + bits: bool, +} +impl TR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR3R { + bits: bool, +} +impl TR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR4R { + bits: bool, +} +impl TR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR5R { + bits: bool, +} +impl TR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR6R { + bits: bool, +} +impl TR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR7R { + bits: bool, +} +impl TR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR8R { + bits: bool, +} +impl TR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR9R { + bits: bool, +} +impl TR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR10R { + bits: bool, +} +impl TR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR11R { + bits: bool, +} +impl TR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR12R { + bits: bool, +} +impl TR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR13R { + bits: bool, +} +impl TR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR14R { + bits: bool, +} +impl TR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR15R { + bits: bool, +} +impl TR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR16R { + bits: bool, +} +impl TR16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR17R { + bits: bool, +} +impl TR17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR18R { + bits: bool, +} +impl TR18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR19R { + bits: bool, +} +impl TR19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR20R { + bits: bool, +} +impl TR20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR21R { + bits: bool, +} +impl TR21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR22R { + bits: bool, +} +impl TR22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TR0W<'a> { + w: &'a mut W, +} +impl<'a> _TR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR1W<'a> { + w: &'a mut W, +} +impl<'a> _TR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR2W<'a> { + w: &'a mut W, +} +impl<'a> _TR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR3W<'a> { + w: &'a mut W, +} +impl<'a> _TR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR4W<'a> { + w: &'a mut W, +} +impl<'a> _TR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR5W<'a> { + w: &'a mut W, +} +impl<'a> _TR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR6W<'a> { + w: &'a mut W, +} +impl<'a> _TR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR7W<'a> { + w: &'a mut W, +} +impl<'a> _TR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR8W<'a> { + w: &'a mut W, +} +impl<'a> _TR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR9W<'a> { + w: &'a mut W, +} +impl<'a> _TR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR10W<'a> { + w: &'a mut W, +} +impl<'a> _TR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR11W<'a> { + w: &'a mut W, +} +impl<'a> _TR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR12W<'a> { + w: &'a mut W, +} +impl<'a> _TR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR13W<'a> { + w: &'a mut W, +} +impl<'a> _TR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR14W<'a> { + w: &'a mut W, +} +impl<'a> _TR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR15W<'a> { + w: &'a mut W, +} +impl<'a> _TR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR16W<'a> { + w: &'a mut W, +} +impl<'a> _TR16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR17W<'a> { + w: &'a mut W, +} +impl<'a> _TR17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR18W<'a> { + w: &'a mut W, +} +impl<'a> _TR18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR19W<'a> { + w: &'a mut W, +} +impl<'a> _TR19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR20W<'a> { + w: &'a mut W, +} +impl<'a> _TR20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR21W<'a> { + w: &'a mut W, +} +impl<'a> _TR21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR22W<'a> { + w: &'a mut W, +} +impl<'a> _TR22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Falling trigger event configuration of line 0"] + #[inline] + pub fn tr0(&self) -> TR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR0R { bits } + } + #[doc = "Bit 1 - Falling trigger event configuration of line 1"] + #[inline] + pub fn tr1(&self) -> TR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR1R { bits } + } + #[doc = "Bit 2 - Falling trigger event configuration of line 2"] + #[inline] + pub fn tr2(&self) -> TR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR2R { bits } + } + #[doc = "Bit 3 - Falling trigger event configuration of line 3"] + #[inline] + pub fn tr3(&self) -> TR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR3R { bits } + } + #[doc = "Bit 4 - Falling trigger event configuration of line 4"] + #[inline] + pub fn tr4(&self) -> TR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR4R { bits } + } + #[doc = "Bit 5 - Falling trigger event configuration of line 5"] + #[inline] + pub fn tr5(&self) -> TR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR5R { bits } + } + #[doc = "Bit 6 - Falling trigger event configuration of line 6"] + #[inline] + pub fn tr6(&self) -> TR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR6R { bits } + } + #[doc = "Bit 7 - Falling trigger event configuration of line 7"] + #[inline] + pub fn tr7(&self) -> TR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR7R { bits } + } + #[doc = "Bit 8 - Falling trigger event configuration of line 8"] + #[inline] + pub fn tr8(&self) -> TR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR8R { bits } + } + #[doc = "Bit 9 - Falling trigger event configuration of line 9"] + #[inline] + pub fn tr9(&self) -> TR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR9R { bits } + } + #[doc = "Bit 10 - Falling trigger event configuration of line 10"] + #[inline] + pub fn tr10(&self) -> TR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR10R { bits } + } + #[doc = "Bit 11 - Falling trigger event configuration of line 11"] + #[inline] + pub fn tr11(&self) -> TR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR11R { bits } + } + #[doc = "Bit 12 - Falling trigger event configuration of line 12"] + #[inline] + pub fn tr12(&self) -> TR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR12R { bits } + } + #[doc = "Bit 13 - Falling trigger event configuration of line 13"] + #[inline] + pub fn tr13(&self) -> TR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR13R { bits } + } + #[doc = "Bit 14 - Falling trigger event configuration of line 14"] + #[inline] + pub fn tr14(&self) -> TR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR14R { bits } + } + #[doc = "Bit 15 - Falling trigger event configuration of line 15"] + #[inline] + pub fn tr15(&self) -> TR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR15R { bits } + } + #[doc = "Bit 16 - Falling trigger event configuration of line 16"] + #[inline] + pub fn tr16(&self) -> TR16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR16R { bits } + } + #[doc = "Bit 17 - Falling trigger event configuration of line 17"] + #[inline] + pub fn tr17(&self) -> TR17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR17R { bits } + } + #[doc = "Bit 18 - Falling trigger event configuration of line 18"] + #[inline] + pub fn tr18(&self) -> TR18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR18R { bits } + } + #[doc = "Bit 19 - Falling trigger event configuration of line 19"] + #[inline] + pub fn tr19(&self) -> TR19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR19R { bits } + } + #[doc = "Bit 20 - Falling trigger event configuration of line 20"] + #[inline] + pub fn tr20(&self) -> TR20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR20R { bits } + } + #[doc = "Bit 21 - Falling trigger event configuration of line 21"] + #[inline] + pub fn tr21(&self) -> TR21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR21R { bits } + } + #[doc = "Bit 22 - Falling trigger event configuration of line 22"] + #[inline] + pub fn tr22(&self) -> TR22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Falling trigger event configuration of line 0"] + #[inline] + pub fn tr0(&mut self) -> _TR0W { + _TR0W { w: self } + } + #[doc = "Bit 1 - Falling trigger event configuration of line 1"] + #[inline] + pub fn tr1(&mut self) -> _TR1W { + _TR1W { w: self } + } + #[doc = "Bit 2 - Falling trigger event configuration of line 2"] + #[inline] + pub fn tr2(&mut self) -> _TR2W { + _TR2W { w: self } + } + #[doc = "Bit 3 - Falling trigger event configuration of line 3"] + #[inline] + pub fn tr3(&mut self) -> _TR3W { + _TR3W { w: self } + } + #[doc = "Bit 4 - Falling trigger event configuration of line 4"] + #[inline] + pub fn tr4(&mut self) -> _TR4W { + _TR4W { w: self } + } + #[doc = "Bit 5 - Falling trigger event configuration of line 5"] + #[inline] + pub fn tr5(&mut self) -> _TR5W { + _TR5W { w: self } + } + #[doc = "Bit 6 - Falling trigger event configuration of line 6"] + #[inline] + pub fn tr6(&mut self) -> _TR6W { + _TR6W { w: self } + } + #[doc = "Bit 7 - Falling trigger event configuration of line 7"] + #[inline] + pub fn tr7(&mut self) -> _TR7W { + _TR7W { w: self } + } + #[doc = "Bit 8 - Falling trigger event configuration of line 8"] + #[inline] + pub fn tr8(&mut self) -> _TR8W { + _TR8W { w: self } + } + #[doc = "Bit 9 - Falling trigger event configuration of line 9"] + #[inline] + pub fn tr9(&mut self) -> _TR9W { + _TR9W { w: self } + } + #[doc = "Bit 10 - Falling trigger event configuration of line 10"] + #[inline] + pub fn tr10(&mut self) -> _TR10W { + _TR10W { w: self } + } + #[doc = "Bit 11 - Falling trigger event configuration of line 11"] + #[inline] + pub fn tr11(&mut self) -> _TR11W { + _TR11W { w: self } + } + #[doc = "Bit 12 - Falling trigger event configuration of line 12"] + #[inline] + pub fn tr12(&mut self) -> _TR12W { + _TR12W { w: self } + } + #[doc = "Bit 13 - Falling trigger event configuration of line 13"] + #[inline] + pub fn tr13(&mut self) -> _TR13W { + _TR13W { w: self } + } + #[doc = "Bit 14 - Falling trigger event configuration of line 14"] + #[inline] + pub fn tr14(&mut self) -> _TR14W { + _TR14W { w: self } + } + #[doc = "Bit 15 - Falling trigger event configuration of line 15"] + #[inline] + pub fn tr15(&mut self) -> _TR15W { + _TR15W { w: self } + } + #[doc = "Bit 16 - Falling trigger event configuration of line 16"] + #[inline] + pub fn tr16(&mut self) -> _TR16W { + _TR16W { w: self } + } + #[doc = "Bit 17 - Falling trigger event configuration of line 17"] + #[inline] + pub fn tr17(&mut self) -> _TR17W { + _TR17W { w: self } + } + #[doc = "Bit 18 - Falling trigger event configuration of line 18"] + #[inline] + pub fn tr18(&mut self) -> _TR18W { + _TR18W { w: self } + } + #[doc = "Bit 19 - Falling trigger event configuration of line 19"] + #[inline] + pub fn tr19(&mut self) -> _TR19W { + _TR19W { w: self } + } + #[doc = "Bit 20 - Falling trigger event configuration of line 20"] + #[inline] + pub fn tr20(&mut self) -> _TR20W { + _TR20W { w: self } + } + #[doc = "Bit 21 - Falling trigger event configuration of line 21"] + #[inline] + pub fn tr21(&mut self) -> _TR21W { + _TR21W { w: self } + } + #[doc = "Bit 22 - Falling trigger event configuration of line 22"] + #[inline] + pub fn tr22(&mut self) -> _TR22W { + _TR22W { w: self } + } +} diff --git a/src/exti/imr/mod.rs b/src/exti/imr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f60032270ab7b0a487d6f0c3dce99dfb59a6179a --- /dev/null +++ b/src/exti/imr/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IMR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MR0R { + bits: bool, +} +impl MR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR1R { + bits: bool, +} +impl MR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR2R { + bits: bool, +} +impl MR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR3R { + bits: bool, +} +impl MR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR4R { + bits: bool, +} +impl MR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR5R { + bits: bool, +} +impl MR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR6R { + bits: bool, +} +impl MR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR7R { + bits: bool, +} +impl MR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR8R { + bits: bool, +} +impl MR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR9R { + bits: bool, +} +impl MR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR10R { + bits: bool, +} +impl MR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR11R { + bits: bool, +} +impl MR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR12R { + bits: bool, +} +impl MR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR13R { + bits: bool, +} +impl MR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR14R { + bits: bool, +} +impl MR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR15R { + bits: bool, +} +impl MR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR16R { + bits: bool, +} +impl MR16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR17R { + bits: bool, +} +impl MR17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR18R { + bits: bool, +} +impl MR18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR19R { + bits: bool, +} +impl MR19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR20R { + bits: bool, +} +impl MR20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR21R { + bits: bool, +} +impl MR21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR22R { + bits: bool, +} +impl MR22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MR0W<'a> { + w: &'a mut W, +} +impl<'a> _MR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR1W<'a> { + w: &'a mut W, +} +impl<'a> _MR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR2W<'a> { + w: &'a mut W, +} +impl<'a> _MR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR3W<'a> { + w: &'a mut W, +} +impl<'a> _MR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR4W<'a> { + w: &'a mut W, +} +impl<'a> _MR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR5W<'a> { + w: &'a mut W, +} +impl<'a> _MR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR6W<'a> { + w: &'a mut W, +} +impl<'a> _MR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR7W<'a> { + w: &'a mut W, +} +impl<'a> _MR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR8W<'a> { + w: &'a mut W, +} +impl<'a> _MR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR9W<'a> { + w: &'a mut W, +} +impl<'a> _MR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR10W<'a> { + w: &'a mut W, +} +impl<'a> _MR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR11W<'a> { + w: &'a mut W, +} +impl<'a> _MR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR12W<'a> { + w: &'a mut W, +} +impl<'a> _MR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR13W<'a> { + w: &'a mut W, +} +impl<'a> _MR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR14W<'a> { + w: &'a mut W, +} +impl<'a> _MR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR15W<'a> { + w: &'a mut W, +} +impl<'a> _MR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR16W<'a> { + w: &'a mut W, +} +impl<'a> _MR16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR17W<'a> { + w: &'a mut W, +} +impl<'a> _MR17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR18W<'a> { + w: &'a mut W, +} +impl<'a> _MR18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR19W<'a> { + w: &'a mut W, +} +impl<'a> _MR19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR20W<'a> { + w: &'a mut W, +} +impl<'a> _MR20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR21W<'a> { + w: &'a mut W, +} +impl<'a> _MR21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MR22W<'a> { + w: &'a mut W, +} +impl<'a> _MR22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Interrupt Mask on line 0"] + #[inline] + pub fn mr0(&self) -> MR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR0R { bits } + } + #[doc = "Bit 1 - Interrupt Mask on line 1"] + #[inline] + pub fn mr1(&self) -> MR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR1R { bits } + } + #[doc = "Bit 2 - Interrupt Mask on line 2"] + #[inline] + pub fn mr2(&self) -> MR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR2R { bits } + } + #[doc = "Bit 3 - Interrupt Mask on line 3"] + #[inline] + pub fn mr3(&self) -> MR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR3R { bits } + } + #[doc = "Bit 4 - Interrupt Mask on line 4"] + #[inline] + pub fn mr4(&self) -> MR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR4R { bits } + } + #[doc = "Bit 5 - Interrupt Mask on line 5"] + #[inline] + pub fn mr5(&self) -> MR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR5R { bits } + } + #[doc = "Bit 6 - Interrupt Mask on line 6"] + #[inline] + pub fn mr6(&self) -> MR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR6R { bits } + } + #[doc = "Bit 7 - Interrupt Mask on line 7"] + #[inline] + pub fn mr7(&self) -> MR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR7R { bits } + } + #[doc = "Bit 8 - Interrupt Mask on line 8"] + #[inline] + pub fn mr8(&self) -> MR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR8R { bits } + } + #[doc = "Bit 9 - Interrupt Mask on line 9"] + #[inline] + pub fn mr9(&self) -> MR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR9R { bits } + } + #[doc = "Bit 10 - Interrupt Mask on line 10"] + #[inline] + pub fn mr10(&self) -> MR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR10R { bits } + } + #[doc = "Bit 11 - Interrupt Mask on line 11"] + #[inline] + pub fn mr11(&self) -> MR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR11R { bits } + } + #[doc = "Bit 12 - Interrupt Mask on line 12"] + #[inline] + pub fn mr12(&self) -> MR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR12R { bits } + } + #[doc = "Bit 13 - Interrupt Mask on line 13"] + #[inline] + pub fn mr13(&self) -> MR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR13R { bits } + } + #[doc = "Bit 14 - Interrupt Mask on line 14"] + #[inline] + pub fn mr14(&self) -> MR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR14R { bits } + } + #[doc = "Bit 15 - Interrupt Mask on line 15"] + #[inline] + pub fn mr15(&self) -> MR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR15R { bits } + } + #[doc = "Bit 16 - Interrupt Mask on line 16"] + #[inline] + pub fn mr16(&self) -> MR16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR16R { bits } + } + #[doc = "Bit 17 - Interrupt Mask on line 17"] + #[inline] + pub fn mr17(&self) -> MR17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR17R { bits } + } + #[doc = "Bit 18 - Interrupt Mask on line 18"] + #[inline] + pub fn mr18(&self) -> MR18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR18R { bits } + } + #[doc = "Bit 19 - Interrupt Mask on line 19"] + #[inline] + pub fn mr19(&self) -> MR19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR19R { bits } + } + #[doc = "Bit 20 - Interrupt Mask on line 20"] + #[inline] + pub fn mr20(&self) -> MR20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR20R { bits } + } + #[doc = "Bit 21 - Interrupt Mask on line 21"] + #[inline] + pub fn mr21(&self) -> MR21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR21R { bits } + } + #[doc = "Bit 22 - Interrupt Mask on line 22"] + #[inline] + pub fn mr22(&self) -> MR22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Interrupt Mask on line 0"] + #[inline] + pub fn mr0(&mut self) -> _MR0W { + _MR0W { w: self } + } + #[doc = "Bit 1 - Interrupt Mask on line 1"] + #[inline] + pub fn mr1(&mut self) -> _MR1W { + _MR1W { w: self } + } + #[doc = "Bit 2 - Interrupt Mask on line 2"] + #[inline] + pub fn mr2(&mut self) -> _MR2W { + _MR2W { w: self } + } + #[doc = "Bit 3 - Interrupt Mask on line 3"] + #[inline] + pub fn mr3(&mut self) -> _MR3W { + _MR3W { w: self } + } + #[doc = "Bit 4 - Interrupt Mask on line 4"] + #[inline] + pub fn mr4(&mut self) -> _MR4W { + _MR4W { w: self } + } + #[doc = "Bit 5 - Interrupt Mask on line 5"] + #[inline] + pub fn mr5(&mut self) -> _MR5W { + _MR5W { w: self } + } + #[doc = "Bit 6 - Interrupt Mask on line 6"] + #[inline] + pub fn mr6(&mut self) -> _MR6W { + _MR6W { w: self } + } + #[doc = "Bit 7 - Interrupt Mask on line 7"] + #[inline] + pub fn mr7(&mut self) -> _MR7W { + _MR7W { w: self } + } + #[doc = "Bit 8 - Interrupt Mask on line 8"] + #[inline] + pub fn mr8(&mut self) -> _MR8W { + _MR8W { w: self } + } + #[doc = "Bit 9 - Interrupt Mask on line 9"] + #[inline] + pub fn mr9(&mut self) -> _MR9W { + _MR9W { w: self } + } + #[doc = "Bit 10 - Interrupt Mask on line 10"] + #[inline] + pub fn mr10(&mut self) -> _MR10W { + _MR10W { w: self } + } + #[doc = "Bit 11 - Interrupt Mask on line 11"] + #[inline] + pub fn mr11(&mut self) -> _MR11W { + _MR11W { w: self } + } + #[doc = "Bit 12 - Interrupt Mask on line 12"] + #[inline] + pub fn mr12(&mut self) -> _MR12W { + _MR12W { w: self } + } + #[doc = "Bit 13 - Interrupt Mask on line 13"] + #[inline] + pub fn mr13(&mut self) -> _MR13W { + _MR13W { w: self } + } + #[doc = "Bit 14 - Interrupt Mask on line 14"] + #[inline] + pub fn mr14(&mut self) -> _MR14W { + _MR14W { w: self } + } + #[doc = "Bit 15 - Interrupt Mask on line 15"] + #[inline] + pub fn mr15(&mut self) -> _MR15W { + _MR15W { w: self } + } + #[doc = "Bit 16 - Interrupt Mask on line 16"] + #[inline] + pub fn mr16(&mut self) -> _MR16W { + _MR16W { w: self } + } + #[doc = "Bit 17 - Interrupt Mask on line 17"] + #[inline] + pub fn mr17(&mut self) -> _MR17W { + _MR17W { w: self } + } + #[doc = "Bit 18 - Interrupt Mask on line 18"] + #[inline] + pub fn mr18(&mut self) -> _MR18W { + _MR18W { w: self } + } + #[doc = "Bit 19 - Interrupt Mask on line 19"] + #[inline] + pub fn mr19(&mut self) -> _MR19W { + _MR19W { w: self } + } + #[doc = "Bit 20 - Interrupt Mask on line 20"] + #[inline] + pub fn mr20(&mut self) -> _MR20W { + _MR20W { w: self } + } + #[doc = "Bit 21 - Interrupt Mask on line 21"] + #[inline] + pub fn mr21(&mut self) -> _MR21W { + _MR21W { w: self } + } + #[doc = "Bit 22 - Interrupt Mask on line 22"] + #[inline] + pub fn mr22(&mut self) -> _MR22W { + _MR22W { w: self } + } +} diff --git a/src/exti/mod.rs b/src/exti/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b34e36b4a9cf13b8fd9c97a1526bf45a373e81f1 --- /dev/null +++ b/src/exti/mod.rs @@ -0,0 +1,52 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Interrupt mask register (EXTI_IMR)"] + pub imr: IMR, + #[doc = "0x04 - Event mask register (EXTI_EMR)"] + pub emr: EMR, + #[doc = "0x08 - Rising Trigger selection register (EXTI_RTSR)"] + pub rtsr: RTSR, + #[doc = "0x0c - Falling Trigger selection register (EXTI_FTSR)"] + pub ftsr: FTSR, + #[doc = "0x10 - Software interrupt event register (EXTI_SWIER)"] + pub swier: SWIER, + #[doc = "0x14 - Pending register (EXTI_PR)"] + pub pr: PR, +} +#[doc = "Interrupt mask register (EXTI_IMR)"] +pub struct IMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt mask register (EXTI_IMR)"] +pub mod imr; +#[doc = "Event mask register (EXTI_EMR)"] +pub struct EMR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Event mask register (EXTI_EMR)"] +pub mod emr; +#[doc = "Rising Trigger selection register (EXTI_RTSR)"] +pub struct RTSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Rising Trigger selection register (EXTI_RTSR)"] +pub mod rtsr; +#[doc = "Falling Trigger selection register (EXTI_FTSR)"] +pub struct FTSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Falling Trigger selection register (EXTI_FTSR)"] +pub mod ftsr; +#[doc = "Software interrupt event register (EXTI_SWIER)"] +pub struct SWIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Software interrupt event register (EXTI_SWIER)"] +pub mod swier; +#[doc = "Pending register (EXTI_PR)"] +pub struct PR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Pending register (EXTI_PR)"] +pub mod pr; diff --git a/src/exti/pr/mod.rs b/src/exti/pr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..466c9229ab253ff1da68dfe289aa383860bea4eb --- /dev/null +++ b/src/exti/pr/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PR0R { + bits: bool, +} +impl PR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR1R { + bits: bool, +} +impl PR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR2R { + bits: bool, +} +impl PR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR3R { + bits: bool, +} +impl PR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR4R { + bits: bool, +} +impl PR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR5R { + bits: bool, +} +impl PR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR6R { + bits: bool, +} +impl PR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR7R { + bits: bool, +} +impl PR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR8R { + bits: bool, +} +impl PR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR9R { + bits: bool, +} +impl PR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR10R { + bits: bool, +} +impl PR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR11R { + bits: bool, +} +impl PR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR12R { + bits: bool, +} +impl PR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR13R { + bits: bool, +} +impl PR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR14R { + bits: bool, +} +impl PR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR15R { + bits: bool, +} +impl PR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR16R { + bits: bool, +} +impl PR16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR17R { + bits: bool, +} +impl PR17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR18R { + bits: bool, +} +impl PR18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR19R { + bits: bool, +} +impl PR19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR20R { + bits: bool, +} +impl PR20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR21R { + bits: bool, +} +impl PR21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PR22R { + bits: bool, +} +impl PR22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _PR0W<'a> { + w: &'a mut W, +} +impl<'a> _PR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR1W<'a> { + w: &'a mut W, +} +impl<'a> _PR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR2W<'a> { + w: &'a mut W, +} +impl<'a> _PR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR3W<'a> { + w: &'a mut W, +} +impl<'a> _PR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR4W<'a> { + w: &'a mut W, +} +impl<'a> _PR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR5W<'a> { + w: &'a mut W, +} +impl<'a> _PR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR6W<'a> { + w: &'a mut W, +} +impl<'a> _PR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR7W<'a> { + w: &'a mut W, +} +impl<'a> _PR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR8W<'a> { + w: &'a mut W, +} +impl<'a> _PR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR9W<'a> { + w: &'a mut W, +} +impl<'a> _PR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR10W<'a> { + w: &'a mut W, +} +impl<'a> _PR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR11W<'a> { + w: &'a mut W, +} +impl<'a> _PR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR12W<'a> { + w: &'a mut W, +} +impl<'a> _PR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR13W<'a> { + w: &'a mut W, +} +impl<'a> _PR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR14W<'a> { + w: &'a mut W, +} +impl<'a> _PR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR15W<'a> { + w: &'a mut W, +} +impl<'a> _PR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR16W<'a> { + w: &'a mut W, +} +impl<'a> _PR16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR17W<'a> { + w: &'a mut W, +} +impl<'a> _PR17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR18W<'a> { + w: &'a mut W, +} +impl<'a> _PR18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR19W<'a> { + w: &'a mut W, +} +impl<'a> _PR19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR20W<'a> { + w: &'a mut W, +} +impl<'a> _PR20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR21W<'a> { + w: &'a mut W, +} +impl<'a> _PR21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PR22W<'a> { + w: &'a mut W, +} +impl<'a> _PR22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Pending bit 0"] + #[inline] + pub fn pr0(&self) -> PR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR0R { bits } + } + #[doc = "Bit 1 - Pending bit 1"] + #[inline] + pub fn pr1(&self) -> PR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR1R { bits } + } + #[doc = "Bit 2 - Pending bit 2"] + #[inline] + pub fn pr2(&self) -> PR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR2R { bits } + } + #[doc = "Bit 3 - Pending bit 3"] + #[inline] + pub fn pr3(&self) -> PR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR3R { bits } + } + #[doc = "Bit 4 - Pending bit 4"] + #[inline] + pub fn pr4(&self) -> PR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR4R { bits } + } + #[doc = "Bit 5 - Pending bit 5"] + #[inline] + pub fn pr5(&self) -> PR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR5R { bits } + } + #[doc = "Bit 6 - Pending bit 6"] + #[inline] + pub fn pr6(&self) -> PR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR6R { bits } + } + #[doc = "Bit 7 - Pending bit 7"] + #[inline] + pub fn pr7(&self) -> PR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR7R { bits } + } + #[doc = "Bit 8 - Pending bit 8"] + #[inline] + pub fn pr8(&self) -> PR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR8R { bits } + } + #[doc = "Bit 9 - Pending bit 9"] + #[inline] + pub fn pr9(&self) -> PR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR9R { bits } + } + #[doc = "Bit 10 - Pending bit 10"] + #[inline] + pub fn pr10(&self) -> PR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR10R { bits } + } + #[doc = "Bit 11 - Pending bit 11"] + #[inline] + pub fn pr11(&self) -> PR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR11R { bits } + } + #[doc = "Bit 12 - Pending bit 12"] + #[inline] + pub fn pr12(&self) -> PR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR12R { bits } + } + #[doc = "Bit 13 - Pending bit 13"] + #[inline] + pub fn pr13(&self) -> PR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR13R { bits } + } + #[doc = "Bit 14 - Pending bit 14"] + #[inline] + pub fn pr14(&self) -> PR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR14R { bits } + } + #[doc = "Bit 15 - Pending bit 15"] + #[inline] + pub fn pr15(&self) -> PR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR15R { bits } + } + #[doc = "Bit 16 - Pending bit 16"] + #[inline] + pub fn pr16(&self) -> PR16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR16R { bits } + } + #[doc = "Bit 17 - Pending bit 17"] + #[inline] + pub fn pr17(&self) -> PR17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR17R { bits } + } + #[doc = "Bit 18 - Pending bit 18"] + #[inline] + pub fn pr18(&self) -> PR18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR18R { bits } + } + #[doc = "Bit 19 - Pending bit 19"] + #[inline] + pub fn pr19(&self) -> PR19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR19R { bits } + } + #[doc = "Bit 20 - Pending bit 20"] + #[inline] + pub fn pr20(&self) -> PR20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR20R { bits } + } + #[doc = "Bit 21 - Pending bit 21"] + #[inline] + pub fn pr21(&self) -> PR21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR21R { bits } + } + #[doc = "Bit 22 - Pending bit 22"] + #[inline] + pub fn pr22(&self) -> PR22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PR22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Pending bit 0"] + #[inline] + pub fn pr0(&mut self) -> _PR0W { + _PR0W { w: self } + } + #[doc = "Bit 1 - Pending bit 1"] + #[inline] + pub fn pr1(&mut self) -> _PR1W { + _PR1W { w: self } + } + #[doc = "Bit 2 - Pending bit 2"] + #[inline] + pub fn pr2(&mut self) -> _PR2W { + _PR2W { w: self } + } + #[doc = "Bit 3 - Pending bit 3"] + #[inline] + pub fn pr3(&mut self) -> _PR3W { + _PR3W { w: self } + } + #[doc = "Bit 4 - Pending bit 4"] + #[inline] + pub fn pr4(&mut self) -> _PR4W { + _PR4W { w: self } + } + #[doc = "Bit 5 - Pending bit 5"] + #[inline] + pub fn pr5(&mut self) -> _PR5W { + _PR5W { w: self } + } + #[doc = "Bit 6 - Pending bit 6"] + #[inline] + pub fn pr6(&mut self) -> _PR6W { + _PR6W { w: self } + } + #[doc = "Bit 7 - Pending bit 7"] + #[inline] + pub fn pr7(&mut self) -> _PR7W { + _PR7W { w: self } + } + #[doc = "Bit 8 - Pending bit 8"] + #[inline] + pub fn pr8(&mut self) -> _PR8W { + _PR8W { w: self } + } + #[doc = "Bit 9 - Pending bit 9"] + #[inline] + pub fn pr9(&mut self) -> _PR9W { + _PR9W { w: self } + } + #[doc = "Bit 10 - Pending bit 10"] + #[inline] + pub fn pr10(&mut self) -> _PR10W { + _PR10W { w: self } + } + #[doc = "Bit 11 - Pending bit 11"] + #[inline] + pub fn pr11(&mut self) -> _PR11W { + _PR11W { w: self } + } + #[doc = "Bit 12 - Pending bit 12"] + #[inline] + pub fn pr12(&mut self) -> _PR12W { + _PR12W { w: self } + } + #[doc = "Bit 13 - Pending bit 13"] + #[inline] + pub fn pr13(&mut self) -> _PR13W { + _PR13W { w: self } + } + #[doc = "Bit 14 - Pending bit 14"] + #[inline] + pub fn pr14(&mut self) -> _PR14W { + _PR14W { w: self } + } + #[doc = "Bit 15 - Pending bit 15"] + #[inline] + pub fn pr15(&mut self) -> _PR15W { + _PR15W { w: self } + } + #[doc = "Bit 16 - Pending bit 16"] + #[inline] + pub fn pr16(&mut self) -> _PR16W { + _PR16W { w: self } + } + #[doc = "Bit 17 - Pending bit 17"] + #[inline] + pub fn pr17(&mut self) -> _PR17W { + _PR17W { w: self } + } + #[doc = "Bit 18 - Pending bit 18"] + #[inline] + pub fn pr18(&mut self) -> _PR18W { + _PR18W { w: self } + } + #[doc = "Bit 19 - Pending bit 19"] + #[inline] + pub fn pr19(&mut self) -> _PR19W { + _PR19W { w: self } + } + #[doc = "Bit 20 - Pending bit 20"] + #[inline] + pub fn pr20(&mut self) -> _PR20W { + _PR20W { w: self } + } + #[doc = "Bit 21 - Pending bit 21"] + #[inline] + pub fn pr21(&mut self) -> _PR21W { + _PR21W { w: self } + } + #[doc = "Bit 22 - Pending bit 22"] + #[inline] + pub fn pr22(&mut self) -> _PR22W { + _PR22W { w: self } + } +} diff --git a/src/exti/rtsr/mod.rs b/src/exti/rtsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0867dc220ad7105f9f11de1562cfa7ee464cbedc --- /dev/null +++ b/src/exti/rtsr/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::RTSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TR0R { + bits: bool, +} +impl TR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR1R { + bits: bool, +} +impl TR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR2R { + bits: bool, +} +impl TR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR3R { + bits: bool, +} +impl TR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR4R { + bits: bool, +} +impl TR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR5R { + bits: bool, +} +impl TR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR6R { + bits: bool, +} +impl TR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR7R { + bits: bool, +} +impl TR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR8R { + bits: bool, +} +impl TR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR9R { + bits: bool, +} +impl TR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR10R { + bits: bool, +} +impl TR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR11R { + bits: bool, +} +impl TR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR12R { + bits: bool, +} +impl TR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR13R { + bits: bool, +} +impl TR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR14R { + bits: bool, +} +impl TR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR15R { + bits: bool, +} +impl TR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR16R { + bits: bool, +} +impl TR16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR17R { + bits: bool, +} +impl TR17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR18R { + bits: bool, +} +impl TR18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR19R { + bits: bool, +} +impl TR19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR20R { + bits: bool, +} +impl TR20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR21R { + bits: bool, +} +impl TR21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR22R { + bits: bool, +} +impl TR22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TR0W<'a> { + w: &'a mut W, +} +impl<'a> _TR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR1W<'a> { + w: &'a mut W, +} +impl<'a> _TR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR2W<'a> { + w: &'a mut W, +} +impl<'a> _TR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR3W<'a> { + w: &'a mut W, +} +impl<'a> _TR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR4W<'a> { + w: &'a mut W, +} +impl<'a> _TR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR5W<'a> { + w: &'a mut W, +} +impl<'a> _TR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR6W<'a> { + w: &'a mut W, +} +impl<'a> _TR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR7W<'a> { + w: &'a mut W, +} +impl<'a> _TR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR8W<'a> { + w: &'a mut W, +} +impl<'a> _TR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR9W<'a> { + w: &'a mut W, +} +impl<'a> _TR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR10W<'a> { + w: &'a mut W, +} +impl<'a> _TR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR11W<'a> { + w: &'a mut W, +} +impl<'a> _TR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR12W<'a> { + w: &'a mut W, +} +impl<'a> _TR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR13W<'a> { + w: &'a mut W, +} +impl<'a> _TR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR14W<'a> { + w: &'a mut W, +} +impl<'a> _TR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR15W<'a> { + w: &'a mut W, +} +impl<'a> _TR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR16W<'a> { + w: &'a mut W, +} +impl<'a> _TR16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR17W<'a> { + w: &'a mut W, +} +impl<'a> _TR17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR18W<'a> { + w: &'a mut W, +} +impl<'a> _TR18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR19W<'a> { + w: &'a mut W, +} +impl<'a> _TR19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR20W<'a> { + w: &'a mut W, +} +impl<'a> _TR20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR21W<'a> { + w: &'a mut W, +} +impl<'a> _TR21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TR22W<'a> { + w: &'a mut W, +} +impl<'a> _TR22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Rising trigger event configuration of line 0"] + #[inline] + pub fn tr0(&self) -> TR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR0R { bits } + } + #[doc = "Bit 1 - Rising trigger event configuration of line 1"] + #[inline] + pub fn tr1(&self) -> TR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR1R { bits } + } + #[doc = "Bit 2 - Rising trigger event configuration of line 2"] + #[inline] + pub fn tr2(&self) -> TR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR2R { bits } + } + #[doc = "Bit 3 - Rising trigger event configuration of line 3"] + #[inline] + pub fn tr3(&self) -> TR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR3R { bits } + } + #[doc = "Bit 4 - Rising trigger event configuration of line 4"] + #[inline] + pub fn tr4(&self) -> TR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR4R { bits } + } + #[doc = "Bit 5 - Rising trigger event configuration of line 5"] + #[inline] + pub fn tr5(&self) -> TR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR5R { bits } + } + #[doc = "Bit 6 - Rising trigger event configuration of line 6"] + #[inline] + pub fn tr6(&self) -> TR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR6R { bits } + } + #[doc = "Bit 7 - Rising trigger event configuration of line 7"] + #[inline] + pub fn tr7(&self) -> TR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR7R { bits } + } + #[doc = "Bit 8 - Rising trigger event configuration of line 8"] + #[inline] + pub fn tr8(&self) -> TR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR8R { bits } + } + #[doc = "Bit 9 - Rising trigger event configuration of line 9"] + #[inline] + pub fn tr9(&self) -> TR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR9R { bits } + } + #[doc = "Bit 10 - Rising trigger event configuration of line 10"] + #[inline] + pub fn tr10(&self) -> TR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR10R { bits } + } + #[doc = "Bit 11 - Rising trigger event configuration of line 11"] + #[inline] + pub fn tr11(&self) -> TR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR11R { bits } + } + #[doc = "Bit 12 - Rising trigger event configuration of line 12"] + #[inline] + pub fn tr12(&self) -> TR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR12R { bits } + } + #[doc = "Bit 13 - Rising trigger event configuration of line 13"] + #[inline] + pub fn tr13(&self) -> TR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR13R { bits } + } + #[doc = "Bit 14 - Rising trigger event configuration of line 14"] + #[inline] + pub fn tr14(&self) -> TR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR14R { bits } + } + #[doc = "Bit 15 - Rising trigger event configuration of line 15"] + #[inline] + pub fn tr15(&self) -> TR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR15R { bits } + } + #[doc = "Bit 16 - Rising trigger event configuration of line 16"] + #[inline] + pub fn tr16(&self) -> TR16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR16R { bits } + } + #[doc = "Bit 17 - Rising trigger event configuration of line 17"] + #[inline] + pub fn tr17(&self) -> TR17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR17R { bits } + } + #[doc = "Bit 18 - Rising trigger event configuration of line 18"] + #[inline] + pub fn tr18(&self) -> TR18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR18R { bits } + } + #[doc = "Bit 19 - Rising trigger event configuration of line 19"] + #[inline] + pub fn tr19(&self) -> TR19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR19R { bits } + } + #[doc = "Bit 20 - Rising trigger event configuration of line 20"] + #[inline] + pub fn tr20(&self) -> TR20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR20R { bits } + } + #[doc = "Bit 21 - Rising trigger event configuration of line 21"] + #[inline] + pub fn tr21(&self) -> TR21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR21R { bits } + } + #[doc = "Bit 22 - Rising trigger event configuration of line 22"] + #[inline] + pub fn tr22(&self) -> TR22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TR22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Rising trigger event configuration of line 0"] + #[inline] + pub fn tr0(&mut self) -> _TR0W { + _TR0W { w: self } + } + #[doc = "Bit 1 - Rising trigger event configuration of line 1"] + #[inline] + pub fn tr1(&mut self) -> _TR1W { + _TR1W { w: self } + } + #[doc = "Bit 2 - Rising trigger event configuration of line 2"] + #[inline] + pub fn tr2(&mut self) -> _TR2W { + _TR2W { w: self } + } + #[doc = "Bit 3 - Rising trigger event configuration of line 3"] + #[inline] + pub fn tr3(&mut self) -> _TR3W { + _TR3W { w: self } + } + #[doc = "Bit 4 - Rising trigger event configuration of line 4"] + #[inline] + pub fn tr4(&mut self) -> _TR4W { + _TR4W { w: self } + } + #[doc = "Bit 5 - Rising trigger event configuration of line 5"] + #[inline] + pub fn tr5(&mut self) -> _TR5W { + _TR5W { w: self } + } + #[doc = "Bit 6 - Rising trigger event configuration of line 6"] + #[inline] + pub fn tr6(&mut self) -> _TR6W { + _TR6W { w: self } + } + #[doc = "Bit 7 - Rising trigger event configuration of line 7"] + #[inline] + pub fn tr7(&mut self) -> _TR7W { + _TR7W { w: self } + } + #[doc = "Bit 8 - Rising trigger event configuration of line 8"] + #[inline] + pub fn tr8(&mut self) -> _TR8W { + _TR8W { w: self } + } + #[doc = "Bit 9 - Rising trigger event configuration of line 9"] + #[inline] + pub fn tr9(&mut self) -> _TR9W { + _TR9W { w: self } + } + #[doc = "Bit 10 - Rising trigger event configuration of line 10"] + #[inline] + pub fn tr10(&mut self) -> _TR10W { + _TR10W { w: self } + } + #[doc = "Bit 11 - Rising trigger event configuration of line 11"] + #[inline] + pub fn tr11(&mut self) -> _TR11W { + _TR11W { w: self } + } + #[doc = "Bit 12 - Rising trigger event configuration of line 12"] + #[inline] + pub fn tr12(&mut self) -> _TR12W { + _TR12W { w: self } + } + #[doc = "Bit 13 - Rising trigger event configuration of line 13"] + #[inline] + pub fn tr13(&mut self) -> _TR13W { + _TR13W { w: self } + } + #[doc = "Bit 14 - Rising trigger event configuration of line 14"] + #[inline] + pub fn tr14(&mut self) -> _TR14W { + _TR14W { w: self } + } + #[doc = "Bit 15 - Rising trigger event configuration of line 15"] + #[inline] + pub fn tr15(&mut self) -> _TR15W { + _TR15W { w: self } + } + #[doc = "Bit 16 - Rising trigger event configuration of line 16"] + #[inline] + pub fn tr16(&mut self) -> _TR16W { + _TR16W { w: self } + } + #[doc = "Bit 17 - Rising trigger event configuration of line 17"] + #[inline] + pub fn tr17(&mut self) -> _TR17W { + _TR17W { w: self } + } + #[doc = "Bit 18 - Rising trigger event configuration of line 18"] + #[inline] + pub fn tr18(&mut self) -> _TR18W { + _TR18W { w: self } + } + #[doc = "Bit 19 - Rising trigger event configuration of line 19"] + #[inline] + pub fn tr19(&mut self) -> _TR19W { + _TR19W { w: self } + } + #[doc = "Bit 20 - Rising trigger event configuration of line 20"] + #[inline] + pub fn tr20(&mut self) -> _TR20W { + _TR20W { w: self } + } + #[doc = "Bit 21 - Rising trigger event configuration of line 21"] + #[inline] + pub fn tr21(&mut self) -> _TR21W { + _TR21W { w: self } + } + #[doc = "Bit 22 - Rising trigger event configuration of line 22"] + #[inline] + pub fn tr22(&mut self) -> _TR22W { + _TR22W { w: self } + } +} diff --git a/src/exti/swier/mod.rs b/src/exti/swier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cc272bfd543ca92347bd2850ef592978b7dd02d8 --- /dev/null +++ b/src/exti/swier/mod.rs @@ -0,0 +1,1421 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SWIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SWIER0R { + bits: bool, +} +impl SWIER0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER1R { + bits: bool, +} +impl SWIER1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER2R { + bits: bool, +} +impl SWIER2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER3R { + bits: bool, +} +impl SWIER3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER4R { + bits: bool, +} +impl SWIER4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER5R { + bits: bool, +} +impl SWIER5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER6R { + bits: bool, +} +impl SWIER6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER7R { + bits: bool, +} +impl SWIER7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER8R { + bits: bool, +} +impl SWIER8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER9R { + bits: bool, +} +impl SWIER9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER10R { + bits: bool, +} +impl SWIER10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER11R { + bits: bool, +} +impl SWIER11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER12R { + bits: bool, +} +impl SWIER12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER13R { + bits: bool, +} +impl SWIER13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER14R { + bits: bool, +} +impl SWIER14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER15R { + bits: bool, +} +impl SWIER15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER16R { + bits: bool, +} +impl SWIER16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER17R { + bits: bool, +} +impl SWIER17R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER18R { + bits: bool, +} +impl SWIER18R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER19R { + bits: bool, +} +impl SWIER19R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER20R { + bits: bool, +} +impl SWIER20R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER21R { + bits: bool, +} +impl SWIER21R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWIER22R { + bits: bool, +} +impl SWIER22R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SWIER0W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER1W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER2W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER3W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER4W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER5W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER6W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER7W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER8W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER9W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER10W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER11W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER12W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER13W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER14W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER15W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER16W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER17W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER17W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER18W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER18W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER19W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER19W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER20W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER20W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER21W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER21W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SWIER22W<'a> { + w: &'a mut W, +} +impl<'a> _SWIER22W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Software Interrupt on line 0"] + #[inline] + pub fn swier0(&self) -> SWIER0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER0R { bits } + } + #[doc = "Bit 1 - Software Interrupt on line 1"] + #[inline] + pub fn swier1(&self) -> SWIER1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER1R { bits } + } + #[doc = "Bit 2 - Software Interrupt on line 2"] + #[inline] + pub fn swier2(&self) -> SWIER2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER2R { bits } + } + #[doc = "Bit 3 - Software Interrupt on line 3"] + #[inline] + pub fn swier3(&self) -> SWIER3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER3R { bits } + } + #[doc = "Bit 4 - Software Interrupt on line 4"] + #[inline] + pub fn swier4(&self) -> SWIER4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER4R { bits } + } + #[doc = "Bit 5 - Software Interrupt on line 5"] + #[inline] + pub fn swier5(&self) -> SWIER5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER5R { bits } + } + #[doc = "Bit 6 - Software Interrupt on line 6"] + #[inline] + pub fn swier6(&self) -> SWIER6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER6R { bits } + } + #[doc = "Bit 7 - Software Interrupt on line 7"] + #[inline] + pub fn swier7(&self) -> SWIER7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER7R { bits } + } + #[doc = "Bit 8 - Software Interrupt on line 8"] + #[inline] + pub fn swier8(&self) -> SWIER8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER8R { bits } + } + #[doc = "Bit 9 - Software Interrupt on line 9"] + #[inline] + pub fn swier9(&self) -> SWIER9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER9R { bits } + } + #[doc = "Bit 10 - Software Interrupt on line 10"] + #[inline] + pub fn swier10(&self) -> SWIER10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER10R { bits } + } + #[doc = "Bit 11 - Software Interrupt on line 11"] + #[inline] + pub fn swier11(&self) -> SWIER11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER11R { bits } + } + #[doc = "Bit 12 - Software Interrupt on line 12"] + #[inline] + pub fn swier12(&self) -> SWIER12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER12R { bits } + } + #[doc = "Bit 13 - Software Interrupt on line 13"] + #[inline] + pub fn swier13(&self) -> SWIER13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER13R { bits } + } + #[doc = "Bit 14 - Software Interrupt on line 14"] + #[inline] + pub fn swier14(&self) -> SWIER14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER14R { bits } + } + #[doc = "Bit 15 - Software Interrupt on line 15"] + #[inline] + pub fn swier15(&self) -> SWIER15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER15R { bits } + } + #[doc = "Bit 16 - Software Interrupt on line 16"] + #[inline] + pub fn swier16(&self) -> SWIER16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER16R { bits } + } + #[doc = "Bit 17 - Software Interrupt on line 17"] + #[inline] + pub fn swier17(&self) -> SWIER17R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER17R { bits } + } + #[doc = "Bit 18 - Software Interrupt on line 18"] + #[inline] + pub fn swier18(&self) -> SWIER18R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER18R { bits } + } + #[doc = "Bit 19 - Software Interrupt on line 19"] + #[inline] + pub fn swier19(&self) -> SWIER19R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER19R { bits } + } + #[doc = "Bit 20 - Software Interrupt on line 20"] + #[inline] + pub fn swier20(&self) -> SWIER20R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER20R { bits } + } + #[doc = "Bit 21 - Software Interrupt on line 21"] + #[inline] + pub fn swier21(&self) -> SWIER21R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER21R { bits } + } + #[doc = "Bit 22 - Software Interrupt on line 22"] + #[inline] + pub fn swier22(&self) -> SWIER22R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWIER22R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Software Interrupt on line 0"] + #[inline] + pub fn swier0(&mut self) -> _SWIER0W { + _SWIER0W { w: self } + } + #[doc = "Bit 1 - Software Interrupt on line 1"] + #[inline] + pub fn swier1(&mut self) -> _SWIER1W { + _SWIER1W { w: self } + } + #[doc = "Bit 2 - Software Interrupt on line 2"] + #[inline] + pub fn swier2(&mut self) -> _SWIER2W { + _SWIER2W { w: self } + } + #[doc = "Bit 3 - Software Interrupt on line 3"] + #[inline] + pub fn swier3(&mut self) -> _SWIER3W { + _SWIER3W { w: self } + } + #[doc = "Bit 4 - Software Interrupt on line 4"] + #[inline] + pub fn swier4(&mut self) -> _SWIER4W { + _SWIER4W { w: self } + } + #[doc = "Bit 5 - Software Interrupt on line 5"] + #[inline] + pub fn swier5(&mut self) -> _SWIER5W { + _SWIER5W { w: self } + } + #[doc = "Bit 6 - Software Interrupt on line 6"] + #[inline] + pub fn swier6(&mut self) -> _SWIER6W { + _SWIER6W { w: self } + } + #[doc = "Bit 7 - Software Interrupt on line 7"] + #[inline] + pub fn swier7(&mut self) -> _SWIER7W { + _SWIER7W { w: self } + } + #[doc = "Bit 8 - Software Interrupt on line 8"] + #[inline] + pub fn swier8(&mut self) -> _SWIER8W { + _SWIER8W { w: self } + } + #[doc = "Bit 9 - Software Interrupt on line 9"] + #[inline] + pub fn swier9(&mut self) -> _SWIER9W { + _SWIER9W { w: self } + } + #[doc = "Bit 10 - Software Interrupt on line 10"] + #[inline] + pub fn swier10(&mut self) -> _SWIER10W { + _SWIER10W { w: self } + } + #[doc = "Bit 11 - Software Interrupt on line 11"] + #[inline] + pub fn swier11(&mut self) -> _SWIER11W { + _SWIER11W { w: self } + } + #[doc = "Bit 12 - Software Interrupt on line 12"] + #[inline] + pub fn swier12(&mut self) -> _SWIER12W { + _SWIER12W { w: self } + } + #[doc = "Bit 13 - Software Interrupt on line 13"] + #[inline] + pub fn swier13(&mut self) -> _SWIER13W { + _SWIER13W { w: self } + } + #[doc = "Bit 14 - Software Interrupt on line 14"] + #[inline] + pub fn swier14(&mut self) -> _SWIER14W { + _SWIER14W { w: self } + } + #[doc = "Bit 15 - Software Interrupt on line 15"] + #[inline] + pub fn swier15(&mut self) -> _SWIER15W { + _SWIER15W { w: self } + } + #[doc = "Bit 16 - Software Interrupt on line 16"] + #[inline] + pub fn swier16(&mut self) -> _SWIER16W { + _SWIER16W { w: self } + } + #[doc = "Bit 17 - Software Interrupt on line 17"] + #[inline] + pub fn swier17(&mut self) -> _SWIER17W { + _SWIER17W { w: self } + } + #[doc = "Bit 18 - Software Interrupt on line 18"] + #[inline] + pub fn swier18(&mut self) -> _SWIER18W { + _SWIER18W { w: self } + } + #[doc = "Bit 19 - Software Interrupt on line 19"] + #[inline] + pub fn swier19(&mut self) -> _SWIER19W { + _SWIER19W { w: self } + } + #[doc = "Bit 20 - Software Interrupt on line 20"] + #[inline] + pub fn swier20(&mut self) -> _SWIER20W { + _SWIER20W { w: self } + } + #[doc = "Bit 21 - Software Interrupt on line 21"] + #[inline] + pub fn swier21(&mut self) -> _SWIER21W { + _SWIER21W { w: self } + } + #[doc = "Bit 22 - Software Interrupt on line 22"] + #[inline] + pub fn swier22(&mut self) -> _SWIER22W { + _SWIER22W { w: self } + } +} diff --git a/src/flash/acr/mod.rs b/src/flash/acr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a67d8f1bec01f33d44e686e40b90128791bc5f58 --- /dev/null +++ b/src/flash/acr/mod.rs @@ -0,0 +1,369 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ACR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LATENCYR { + bits: u8, +} +impl LATENCYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PRFTENR { + bits: bool, +} +impl PRFTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ICENR { + bits: bool, +} +impl ICENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCENR { + bits: bool, +} +impl DCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCRSTR { + bits: bool, +} +impl DCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LATENCYW<'a> { + w: &'a mut W, +} +impl<'a> _LATENCYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRFTENW<'a> { + w: &'a mut W, +} +impl<'a> _PRFTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICENW<'a> { + w: &'a mut W, +} +impl<'a> _ICENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCENW<'a> { + w: &'a mut W, +} +impl<'a> _DCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICRSTW<'a> { + w: &'a mut W, +} +impl<'a> _ICRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _DCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:2 - Latency"] + #[inline] + pub fn latency(&self) -> LATENCYR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + LATENCYR { bits } + } + #[doc = "Bit 8 - Prefetch enable"] + #[inline] + pub fn prften(&self) -> PRFTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PRFTENR { bits } + } + #[doc = "Bit 9 - Instruction cache enable"] + #[inline] + pub fn icen(&self) -> ICENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ICENR { bits } + } + #[doc = "Bit 10 - Data cache enable"] + #[inline] + pub fn dcen(&self) -> DCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCENR { bits } + } + #[doc = "Bit 12 - Data cache reset"] + #[inline] + pub fn dcrst(&self) -> DCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCRSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:2 - Latency"] + #[inline] + pub fn latency(&mut self) -> _LATENCYW { + _LATENCYW { w: self } + } + #[doc = "Bit 8 - Prefetch enable"] + #[inline] + pub fn prften(&mut self) -> _PRFTENW { + _PRFTENW { w: self } + } + #[doc = "Bit 9 - Instruction cache enable"] + #[inline] + pub fn icen(&mut self) -> _ICENW { + _ICENW { w: self } + } + #[doc = "Bit 10 - Data cache enable"] + #[inline] + pub fn dcen(&mut self) -> _DCENW { + _DCENW { w: self } + } + #[doc = "Bit 11 - Instruction cache reset"] + #[inline] + pub fn icrst(&mut self) -> _ICRSTW { + _ICRSTW { w: self } + } + #[doc = "Bit 12 - Data cache reset"] + #[inline] + pub fn dcrst(&mut self) -> _DCRSTW { + _DCRSTW { w: self } + } +} diff --git a/src/flash/cr/mod.rs b/src/flash/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..225fbdfbb96c80062d0fbd9ea2c6f46b5c7a61aa --- /dev/null +++ b/src/flash/cr/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PGR { + bits: bool, +} +impl PGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SERR { + bits: bool, +} +impl SERR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MERR { + bits: bool, +} +impl MERR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNBR { + bits: u8, +} +impl SNBR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSIZER { + bits: u8, +} +impl PSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STRTR { + bits: bool, +} +impl STRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOPIER { + bits: bool, +} +impl EOPIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIER { + bits: bool, +} +impl ERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LOCKR { + bits: bool, +} +impl LOCKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _PGW<'a> { + w: &'a mut W, +} +impl<'a> _PGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SERW<'a> { + w: &'a mut W, +} +impl<'a> _SERW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MERW<'a> { + w: &'a mut W, +} +impl<'a> _MERW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNBW<'a> { + w: &'a mut W, +} +impl<'a> _SNBW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _PSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STRTW<'a> { + w: &'a mut W, +} +impl<'a> _STRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOPIEW<'a> { + w: &'a mut W, +} +impl<'a> _EOPIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LOCKW<'a> { + w: &'a mut W, +} +impl<'a> _LOCKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Programming"] + #[inline] + pub fn pg(&self) -> PGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PGR { bits } + } + #[doc = "Bit 1 - Sector Erase"] + #[inline] + pub fn ser(&self) -> SERR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SERR { bits } + } + #[doc = "Bit 2 - Mass Erase"] + #[inline] + pub fn mer(&self) -> MERR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MERR { bits } + } + #[doc = "Bits 3:6 - Sector number"] + #[inline] + pub fn snb(&self) -> SNBR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SNBR { bits } + } + #[doc = "Bits 8:9 - Program size"] + #[inline] + pub fn psize(&self) -> PSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSIZER { bits } + } + #[doc = "Bit 16 - Start"] + #[inline] + pub fn strt(&self) -> STRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STRTR { bits } + } + #[doc = "Bit 24 - End of operation interrupt enable"] + #[inline] + pub fn eopie(&self) -> EOPIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOPIER { bits } + } + #[doc = "Bit 25 - Error interrupt enable"] + #[inline] + pub fn errie(&self) -> ERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIER { bits } + } + #[doc = "Bit 31 - Lock"] + #[inline] + pub fn lock(&self) -> LOCKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LOCKR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2147483648 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Programming"] + #[inline] + pub fn pg(&mut self) -> _PGW { + _PGW { w: self } + } + #[doc = "Bit 1 - Sector Erase"] + #[inline] + pub fn ser(&mut self) -> _SERW { + _SERW { w: self } + } + #[doc = "Bit 2 - Mass Erase"] + #[inline] + pub fn mer(&mut self) -> _MERW { + _MERW { w: self } + } + #[doc = "Bits 3:6 - Sector number"] + #[inline] + pub fn snb(&mut self) -> _SNBW { + _SNBW { w: self } + } + #[doc = "Bits 8:9 - Program size"] + #[inline] + pub fn psize(&mut self) -> _PSIZEW { + _PSIZEW { w: self } + } + #[doc = "Bit 16 - Start"] + #[inline] + pub fn strt(&mut self) -> _STRTW { + _STRTW { w: self } + } + #[doc = "Bit 24 - End of operation interrupt enable"] + #[inline] + pub fn eopie(&mut self) -> _EOPIEW { + _EOPIEW { w: self } + } + #[doc = "Bit 25 - Error interrupt enable"] + #[inline] + pub fn errie(&mut self) -> _ERRIEW { + _ERRIEW { w: self } + } + #[doc = "Bit 31 - Lock"] + #[inline] + pub fn lock(&mut self) -> _LOCKW { + _LOCKW { w: self } + } +} diff --git a/src/flash/keyr/mod.rs b/src/flash/keyr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4a161b5716c06d3167c1ede2c33270d4392381ce --- /dev/null +++ b/src/flash/keyr/mod.rs @@ -0,0 +1,49 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KEYR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _KEYW<'a> { + w: &'a mut W, +} +impl<'a> _KEYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - FPEC key"] + #[inline] + pub fn key(&mut self) -> _KEYW { + _KEYW { w: self } + } +} diff --git a/src/flash/mod.rs b/src/flash/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e2a35577a80ffd2df4647c9a43378b1af18a976 --- /dev/null +++ b/src/flash/mod.rs @@ -0,0 +1,52 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Flash access control register"] + pub acr: ACR, + #[doc = "0x04 - Flash key register"] + pub keyr: KEYR, + #[doc = "0x08 - Flash option key register"] + pub optkeyr: OPTKEYR, + #[doc = "0x0c - Status register"] + pub sr: SR, + #[doc = "0x10 - Control register"] + pub cr: CR, + #[doc = "0x14 - Flash option control register"] + pub optcr: OPTCR, +} +#[doc = "Flash access control register"] +pub struct ACR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Flash access control register"] +pub mod acr; +#[doc = "Flash key register"] +pub struct KEYR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Flash key register"] +pub mod keyr; +#[doc = "Flash option key register"] +pub struct OPTKEYR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Flash option key register"] +pub mod optkeyr; +#[doc = "Status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register"] +pub mod sr; +#[doc = "Control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register"] +pub mod cr; +#[doc = "Flash option control register"] +pub struct OPTCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Flash option control register"] +pub mod optcr; diff --git a/src/flash/optcr/mod.rs b/src/flash/optcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eabcfd185b44d0cefee1d5dac5a1f41184c48472 --- /dev/null +++ b/src/flash/optcr/mod.rs @@ -0,0 +1,482 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OPTCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OPTLOCKR { + bits: bool, +} +impl OPTLOCKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPTSTRTR { + bits: bool, +} +impl OPTSTRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BOR_LEVR { + bits: u8, +} +impl BOR_LEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct WDG_SWR { + bits: bool, +} +impl WDG_SWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NRST_STOPR { + bits: bool, +} +impl NRST_STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NRST_STDBYR { + bits: bool, +} +impl NRST_STDBYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RDPR { + bits: u8, +} +impl RDPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NWRPR { + bits: u16, +} +impl NWRPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OPTLOCKW<'a> { + w: &'a mut W, +} +impl<'a> _OPTLOCKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPTSTRTW<'a> { + w: &'a mut W, +} +impl<'a> _OPTSTRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BOR_LEVW<'a> { + w: &'a mut W, +} +impl<'a> _BOR_LEVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDG_SWW<'a> { + w: &'a mut W, +} +impl<'a> _WDG_SWW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NRST_STOPW<'a> { + w: &'a mut W, +} +impl<'a> _NRST_STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NRST_STDBYW<'a> { + w: &'a mut W, +} +impl<'a> _NRST_STDBYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RDPW<'a> { + w: &'a mut W, +} +impl<'a> _RDPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NWRPW<'a> { + w: &'a mut W, +} +impl<'a> _NWRPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Option lock"] + #[inline] + pub fn optlock(&self) -> OPTLOCKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPTLOCKR { bits } + } + #[doc = "Bit 1 - Option start"] + #[inline] + pub fn optstrt(&self) -> OPTSTRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPTSTRTR { bits } + } + #[doc = "Bits 2:3 - BOR reset Level"] + #[inline] + pub fn bor_lev(&self) -> BOR_LEVR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BOR_LEVR { bits } + } + #[doc = "Bit 5 - WDG_SW User option bytes"] + #[inline] + pub fn wdg_sw(&self) -> WDG_SWR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDG_SWR { bits } + } + #[doc = "Bit 6 - nRST_STOP User option bytes"] + #[inline] + pub fn n_rst_stop(&self) -> NRST_STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NRST_STOPR { bits } + } + #[doc = "Bit 7 - nRST_STDBY User option bytes"] + #[inline] + pub fn n_rst_stdby(&self) -> NRST_STDBYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NRST_STDBYR { bits } + } + #[doc = "Bits 8:15 - Read protect"] + #[inline] + pub fn rdp(&self) -> RDPR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RDPR { bits } + } + #[doc = "Bits 16:27 - Not write protect"] + #[inline] + pub fn n_wrp(&self) -> NWRPR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NWRPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 20 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Option lock"] + #[inline] + pub fn optlock(&mut self) -> _OPTLOCKW { + _OPTLOCKW { w: self } + } + #[doc = "Bit 1 - Option start"] + #[inline] + pub fn optstrt(&mut self) -> _OPTSTRTW { + _OPTSTRTW { w: self } + } + #[doc = "Bits 2:3 - BOR reset Level"] + #[inline] + pub fn bor_lev(&mut self) -> _BOR_LEVW { + _BOR_LEVW { w: self } + } + #[doc = "Bit 5 - WDG_SW User option bytes"] + #[inline] + pub fn wdg_sw(&mut self) -> _WDG_SWW { + _WDG_SWW { w: self } + } + #[doc = "Bit 6 - nRST_STOP User option bytes"] + #[inline] + pub fn n_rst_stop(&mut self) -> _NRST_STOPW { + _NRST_STOPW { w: self } + } + #[doc = "Bit 7 - nRST_STDBY User option bytes"] + #[inline] + pub fn n_rst_stdby(&mut self) -> _NRST_STDBYW { + _NRST_STDBYW { w: self } + } + #[doc = "Bits 8:15 - Read protect"] + #[inline] + pub fn rdp(&mut self) -> _RDPW { + _RDPW { w: self } + } + #[doc = "Bits 16:27 - Not write protect"] + #[inline] + pub fn n_wrp(&mut self) -> _NWRPW { + _NWRPW { w: self } + } +} diff --git a/src/flash/optkeyr/mod.rs b/src/flash/optkeyr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab4a24779c07d30470e5e06b7d8d23cfc5b013cb --- /dev/null +++ b/src/flash/optkeyr/mod.rs @@ -0,0 +1,49 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OPTKEYR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _OPTKEYW<'a> { + w: &'a mut W, +} +impl<'a> _OPTKEYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Option byte key"] + #[inline] + pub fn optkey(&mut self) -> _OPTKEYW { + _OPTKEYW { w: self } + } +} diff --git a/src/flash/sr/mod.rs b/src/flash/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..02037dba67df5f91a8f4732acac4f13304cbc978 --- /dev/null +++ b/src/flash/sr/mod.rs @@ -0,0 +1,449 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EOPR { + bits: bool, +} +impl EOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPERRR { + bits: bool, +} +impl OPERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRPERRR { + bits: bool, +} +impl WRPERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PGAERRR { + bits: bool, +} +impl PGAERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PGPERRR { + bits: bool, +} +impl PGPERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PGSERRR { + bits: bool, +} +impl PGSERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BSYR { + bits: bool, +} +impl BSYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _EOPW<'a> { + w: &'a mut W, +} +impl<'a> _EOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPERRW<'a> { + w: &'a mut W, +} +impl<'a> _OPERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRPERRW<'a> { + w: &'a mut W, +} +impl<'a> _WRPERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PGAERRW<'a> { + w: &'a mut W, +} +impl<'a> _PGAERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PGPERRW<'a> { + w: &'a mut W, +} +impl<'a> _PGPERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PGSERRW<'a> { + w: &'a mut W, +} +impl<'a> _PGSERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - End of operation"] + #[inline] + pub fn eop(&self) -> EOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOPR { bits } + } + #[doc = "Bit 1 - Operation error"] + #[inline] + pub fn operr(&self) -> OPERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPERRR { bits } + } + #[doc = "Bit 4 - Write protection error"] + #[inline] + pub fn wrperr(&self) -> WRPERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRPERRR { bits } + } + #[doc = "Bit 5 - Programming alignment error"] + #[inline] + pub fn pgaerr(&self) -> PGAERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PGAERRR { bits } + } + #[doc = "Bit 6 - Programming parallelism error"] + #[inline] + pub fn pgperr(&self) -> PGPERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PGPERRR { bits } + } + #[doc = "Bit 7 - Programming sequence error"] + #[inline] + pub fn pgserr(&self) -> PGSERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PGSERRR { bits } + } + #[doc = "Bit 16 - Busy"] + #[inline] + pub fn bsy(&self) -> BSYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BSYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - End of operation"] + #[inline] + pub fn eop(&mut self) -> _EOPW { + _EOPW { w: self } + } + #[doc = "Bit 1 - Operation error"] + #[inline] + pub fn operr(&mut self) -> _OPERRW { + _OPERRW { w: self } + } + #[doc = "Bit 4 - Write protection error"] + #[inline] + pub fn wrperr(&mut self) -> _WRPERRW { + _WRPERRW { w: self } + } + #[doc = "Bit 5 - Programming alignment error"] + #[inline] + pub fn pgaerr(&mut self) -> _PGAERRW { + _PGAERRW { w: self } + } + #[doc = "Bit 6 - Programming parallelism error"] + #[inline] + pub fn pgperr(&mut self) -> _PGPERRW { + _PGPERRW { w: self } + } + #[doc = "Bit 7 - Programming sequence error"] + #[inline] + pub fn pgserr(&mut self) -> _PGSERRW { + _PGSERRW { w: self } + } +} diff --git a/src/fmpi2c/cr1/mod.rs b/src/fmpi2c/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fc966370799318846eecb1d8cde82561ddada6e8 --- /dev/null +++ b/src/fmpi2c/cr1/mod.rs @@ -0,0 +1,1167 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PER { + bits: bool, +} +impl PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXIER { + bits: bool, +} +impl TXIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXIER { + bits: bool, +} +impl RXIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADDRER { + bits: bool, +} +impl ADDRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NACKIER { + bits: bool, +} +impl NACKIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPIER { + bits: bool, +} +impl STOPIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIER { + bits: bool, +} +impl ERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DNFR { + bits: u8, +} +impl DNFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ANFOFFR { + bits: bool, +} +impl ANFOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCDMAENR { + bits: bool, +} +impl TCDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXDMAENR { + bits: bool, +} +impl RXDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SBCR { + bits: bool, +} +impl SBCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NOSTRETCHR { + bits: bool, +} +impl NOSTRETCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GCENR { + bits: bool, +} +impl GCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBHENR { + bits: bool, +} +impl SMBHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBDENR { + bits: bool, +} +impl SMBDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALERTENR { + bits: bool, +} +impl ALERTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PECENR { + bits: bool, +} +impl PECENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _PEW<'a> { + w: &'a mut W, +} +impl<'a> _PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDREW<'a> { + w: &'a mut W, +} +impl<'a> _ADDREW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NACKIEW<'a> { + w: &'a mut W, +} +impl<'a> _NACKIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STOPIEW<'a> { + w: &'a mut W, +} +impl<'a> _STOPIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DNFW<'a> { + w: &'a mut W, +} +impl<'a> _DNFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ANFOFFW<'a> { + w: &'a mut W, +} +impl<'a> _ANFOFFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _TCDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RXDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SBCW<'a> { + w: &'a mut W, +} +impl<'a> _SBCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NOSTRETCHW<'a> { + w: &'a mut W, +} +impl<'a> _NOSTRETCHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GCENW<'a> { + w: &'a mut W, +} +impl<'a> _GCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMBHENW<'a> { + w: &'a mut W, +} +impl<'a> _SMBHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMBDENW<'a> { + w: &'a mut W, +} +impl<'a> _SMBDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALERTENW<'a> { + w: &'a mut W, +} +impl<'a> _ALERTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PECENW<'a> { + w: &'a mut W, +} +impl<'a> _PECENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Peripheral enable"] + #[inline] + pub fn pe(&self) -> PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PER { bits } + } + #[doc = "Bit 1 - TXIE"] + #[inline] + pub fn txie(&self) -> TXIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXIER { bits } + } + #[doc = "Bit 2 - RXIE"] + #[inline] + pub fn rxie(&self) -> RXIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXIER { bits } + } + #[doc = "Bit 3 - ADDRE"] + #[inline] + pub fn addre(&self) -> ADDRER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADDRER { bits } + } + #[doc = "Bit 4 - NACKIE"] + #[inline] + pub fn nackie(&self) -> NACKIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NACKIER { bits } + } + #[doc = "Bit 5 - STOPIE"] + #[inline] + pub fn stopie(&self) -> STOPIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STOPIER { bits } + } + #[doc = "Bit 6 - TCIE"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 7 - ERRIE"] + #[inline] + pub fn errie(&self) -> ERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIER { bits } + } + #[doc = "Bits 8:11 - DNF"] + #[inline] + pub fn dnf(&self) -> DNFR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DNFR { bits } + } + #[doc = "Bit 12 - ANFOFF"] + #[inline] + pub fn anfoff(&self) -> ANFOFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ANFOFFR { bits } + } + #[doc = "Bit 14 - TCDMAEN"] + #[inline] + pub fn tcdmaen(&self) -> TCDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCDMAENR { bits } + } + #[doc = "Bit 15 - RXDMAEN"] + #[inline] + pub fn rxdmaen(&self) -> RXDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXDMAENR { bits } + } + #[doc = "Bit 16 - SBC"] + #[inline] + pub fn sbc(&self) -> SBCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SBCR { bits } + } + #[doc = "Bit 17 - NOSTRETCH"] + #[inline] + pub fn nostretch(&self) -> NOSTRETCHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NOSTRETCHR { bits } + } + #[doc = "Bit 19 - GCEN"] + #[inline] + pub fn gcen(&self) -> GCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GCENR { bits } + } + #[doc = "Bit 20 - SMBHEN"] + #[inline] + pub fn smbhen(&self) -> SMBHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBHENR { bits } + } + #[doc = "Bit 21 - SMBDEN"] + #[inline] + pub fn smbden(&self) -> SMBDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBDENR { bits } + } + #[doc = "Bit 22 - ALERTEN"] + #[inline] + pub fn alerten(&self) -> ALERTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALERTENR { bits } + } + #[doc = "Bit 23 - PECEN"] + #[inline] + pub fn pecen(&self) -> PECENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PECENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Peripheral enable"] + #[inline] + pub fn pe(&mut self) -> _PEW { + _PEW { w: self } + } + #[doc = "Bit 1 - TXIE"] + #[inline] + pub fn txie(&mut self) -> _TXIEW { + _TXIEW { w: self } + } + #[doc = "Bit 2 - RXIE"] + #[inline] + pub fn rxie(&mut self) -> _RXIEW { + _RXIEW { w: self } + } + #[doc = "Bit 3 - ADDRE"] + #[inline] + pub fn addre(&mut self) -> _ADDREW { + _ADDREW { w: self } + } + #[doc = "Bit 4 - NACKIE"] + #[inline] + pub fn nackie(&mut self) -> _NACKIEW { + _NACKIEW { w: self } + } + #[doc = "Bit 5 - STOPIE"] + #[inline] + pub fn stopie(&mut self) -> _STOPIEW { + _STOPIEW { w: self } + } + #[doc = "Bit 6 - TCIE"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 7 - ERRIE"] + #[inline] + pub fn errie(&mut self) -> _ERRIEW { + _ERRIEW { w: self } + } + #[doc = "Bits 8:11 - DNF"] + #[inline] + pub fn dnf(&mut self) -> _DNFW { + _DNFW { w: self } + } + #[doc = "Bit 12 - ANFOFF"] + #[inline] + pub fn anfoff(&mut self) -> _ANFOFFW { + _ANFOFFW { w: self } + } + #[doc = "Bit 14 - TCDMAEN"] + #[inline] + pub fn tcdmaen(&mut self) -> _TCDMAENW { + _TCDMAENW { w: self } + } + #[doc = "Bit 15 - RXDMAEN"] + #[inline] + pub fn rxdmaen(&mut self) -> _RXDMAENW { + _RXDMAENW { w: self } + } + #[doc = "Bit 16 - SBC"] + #[inline] + pub fn sbc(&mut self) -> _SBCW { + _SBCW { w: self } + } + #[doc = "Bit 17 - NOSTRETCH"] + #[inline] + pub fn nostretch(&mut self) -> _NOSTRETCHW { + _NOSTRETCHW { w: self } + } + #[doc = "Bit 19 - GCEN"] + #[inline] + pub fn gcen(&mut self) -> _GCENW { + _GCENW { w: self } + } + #[doc = "Bit 20 - SMBHEN"] + #[inline] + pub fn smbhen(&mut self) -> _SMBHENW { + _SMBHENW { w: self } + } + #[doc = "Bit 21 - SMBDEN"] + #[inline] + pub fn smbden(&mut self) -> _SMBDENW { + _SMBDENW { w: self } + } + #[doc = "Bit 22 - ALERTEN"] + #[inline] + pub fn alerten(&mut self) -> _ALERTENW { + _ALERTENW { w: self } + } + #[doc = "Bit 23 - PECEN"] + #[inline] + pub fn pecen(&mut self) -> _PECENW { + _PECENW { w: self } + } +} diff --git a/src/fmpi2c/cr2/mod.rs b/src/fmpi2c/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..78e56135d724c668d791f9f7e51aa30afea6f92e --- /dev/null +++ b/src/fmpi2c/cr2/mod.rs @@ -0,0 +1,777 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SADD0R { + bits: bool, +} +impl SADD0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SADD1_7R { + bits: u8, +} +impl SADD1_7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SADD8_9R { + bits: u8, +} +impl SADD8_9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RD_WRNR { + bits: bool, +} +impl RD_WRNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADD10R { + bits: bool, +} +impl ADD10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HEAD10RR { + bits: bool, +} +impl HEAD10RR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STARTR { + bits: bool, +} +impl STARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPR { + bits: bool, +} +impl STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NACKR { + bits: bool, +} +impl NACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NBYTESR { + bits: u8, +} +impl NBYTESR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RELOADR { + bits: bool, +} +impl RELOADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AUTOENDR { + bits: bool, +} +impl AUTOENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PECBYTER { + bits: bool, +} +impl PECBYTER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SADD0W<'a> { + w: &'a mut W, +} +impl<'a> _SADD0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SADD1_7W<'a> { + w: &'a mut W, +} +impl<'a> _SADD1_7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SADD8_9W<'a> { + w: &'a mut W, +} +impl<'a> _SADD8_9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RD_WRNW<'a> { + w: &'a mut W, +} +impl<'a> _RD_WRNW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADD10W<'a> { + w: &'a mut W, +} +impl<'a> _ADD10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HEAD10RW<'a> { + w: &'a mut W, +} +impl<'a> _HEAD10RW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STARTW<'a> { + w: &'a mut W, +} +impl<'a> _STARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STOPW<'a> { + w: &'a mut W, +} +impl<'a> _STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NACKW<'a> { + w: &'a mut W, +} +impl<'a> _NACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NBYTESW<'a> { + w: &'a mut W, +} +impl<'a> _NBYTESW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RELOADW<'a> { + w: &'a mut W, +} +impl<'a> _RELOADW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AUTOENDW<'a> { + w: &'a mut W, +} +impl<'a> _AUTOENDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PECBYTEW<'a> { + w: &'a mut W, +} +impl<'a> _PECBYTEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Slave address bit 0"] + #[inline] + pub fn sadd0(&self) -> SADD0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SADD0R { bits } + } + #[doc = "Bits 1:7 - Slave address bit 7_1"] + #[inline] + pub fn sadd1_7(&self) -> SADD1_7R { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SADD1_7R { bits } + } + #[doc = "Bits 8:9 - Slave address bit 8_9"] + #[inline] + pub fn sadd8_9(&self) -> SADD8_9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SADD8_9R { bits } + } + #[doc = "Bit 10 - Transfer direction"] + #[inline] + pub fn rd_wrn(&self) -> RD_WRNR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RD_WRNR { bits } + } + #[doc = "Bit 11 - 10-bit addressing mode"] + #[inline] + pub fn add10(&self) -> ADD10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADD10R { bits } + } + #[doc = "Bit 12 - 10-bit address header only read direction"] + #[inline] + pub fn head10r(&self) -> HEAD10RR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HEAD10RR { bits } + } + #[doc = "Bit 13 - Start generation"] + #[inline] + pub fn start(&self) -> STARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STARTR { bits } + } + #[doc = "Bit 14 - Stop generation"] + #[inline] + pub fn stop(&self) -> STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STOPR { bits } + } + #[doc = "Bit 15 - NACK generation"] + #[inline] + pub fn nack(&self) -> NACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NACKR { bits } + } + #[doc = "Bits 16:23 - Number of bytes"] + #[inline] + pub fn nbytes(&self) -> NBYTESR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + NBYTESR { bits } + } + #[doc = "Bit 24 - NBYTES reload mode"] + #[inline] + pub fn reload(&self) -> RELOADR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RELOADR { bits } + } + #[doc = "Bit 25 - Automatic end mode"] + #[inline] + pub fn autoend(&self) -> AUTOENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AUTOENDR { bits } + } + #[doc = "Bit 26 - Packet error checking byte"] + #[inline] + pub fn pecbyte(&self) -> PECBYTER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PECBYTER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Slave address bit 0"] + #[inline] + pub fn sadd0(&mut self) -> _SADD0W { + _SADD0W { w: self } + } + #[doc = "Bits 1:7 - Slave address bit 7_1"] + #[inline] + pub fn sadd1_7(&mut self) -> _SADD1_7W { + _SADD1_7W { w: self } + } + #[doc = "Bits 8:9 - Slave address bit 8_9"] + #[inline] + pub fn sadd8_9(&mut self) -> _SADD8_9W { + _SADD8_9W { w: self } + } + #[doc = "Bit 10 - Transfer direction"] + #[inline] + pub fn rd_wrn(&mut self) -> _RD_WRNW { + _RD_WRNW { w: self } + } + #[doc = "Bit 11 - 10-bit addressing mode"] + #[inline] + pub fn add10(&mut self) -> _ADD10W { + _ADD10W { w: self } + } + #[doc = "Bit 12 - 10-bit address header only read direction"] + #[inline] + pub fn head10r(&mut self) -> _HEAD10RW { + _HEAD10RW { w: self } + } + #[doc = "Bit 13 - Start generation"] + #[inline] + pub fn start(&mut self) -> _STARTW { + _STARTW { w: self } + } + #[doc = "Bit 14 - Stop generation"] + #[inline] + pub fn stop(&mut self) -> _STOPW { + _STOPW { w: self } + } + #[doc = "Bit 15 - NACK generation"] + #[inline] + pub fn nack(&mut self) -> _NACKW { + _NACKW { w: self } + } + #[doc = "Bits 16:23 - Number of bytes"] + #[inline] + pub fn nbytes(&mut self) -> _NBYTESW { + _NBYTESW { w: self } + } + #[doc = "Bit 24 - NBYTES reload mode"] + #[inline] + pub fn reload(&mut self) -> _RELOADW { + _RELOADW { w: self } + } + #[doc = "Bit 25 - Automatic end mode"] + #[inline] + pub fn autoend(&mut self) -> _AUTOENDW { + _AUTOENDW { w: self } + } + #[doc = "Bit 26 - Packet error checking byte"] + #[inline] + pub fn pecbyte(&mut self) -> _PECBYTEW { + _PECBYTEW { w: self } + } +} diff --git a/src/fmpi2c/icr/mod.rs b/src/fmpi2c/icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0050d2d6b8a7eac38ca11d6fe1de3db5f8b18a39 --- /dev/null +++ b/src/fmpi2c/icr/mod.rs @@ -0,0 +1,281 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ICR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _ADDRCFW<'a> { + w: &'a mut W, +} +impl<'a> _ADDRCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NACKCFW<'a> { + w: &'a mut W, +} +impl<'a> _NACKCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STOPCFW<'a> { + w: &'a mut W, +} +impl<'a> _STOPCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BERRCFW<'a> { + w: &'a mut W, +} +impl<'a> _BERRCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARLOCFW<'a> { + w: &'a mut W, +} +impl<'a> _ARLOCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRCFW<'a> { + w: &'a mut W, +} +impl<'a> _OVRCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PECCFW<'a> { + w: &'a mut W, +} +impl<'a> _PECCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMOUTCFW<'a> { + w: &'a mut W, +} +impl<'a> _TIMOUTCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALERTCFW<'a> { + w: &'a mut W, +} +impl<'a> _ALERTCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Address matched flag clear"] + #[inline] + pub fn addrcf(&mut self) -> _ADDRCFW { + _ADDRCFW { w: self } + } + #[doc = "Bit 4 - Not Acknowledge flag clear"] + #[inline] + pub fn nackcf(&mut self) -> _NACKCFW { + _NACKCFW { w: self } + } + #[doc = "Bit 5 - Stop detection flag clear"] + #[inline] + pub fn stopcf(&mut self) -> _STOPCFW { + _STOPCFW { w: self } + } + #[doc = "Bit 8 - Bus error flag clear"] + #[inline] + pub fn berrcf(&mut self) -> _BERRCFW { + _BERRCFW { w: self } + } + #[doc = "Bit 9 - Arbitration Lost flag clear"] + #[inline] + pub fn arlocf(&mut self) -> _ARLOCFW { + _ARLOCFW { w: self } + } + #[doc = "Bit 10 - Overrun/Underrun flag clear"] + #[inline] + pub fn ovrcf(&mut self) -> _OVRCFW { + _OVRCFW { w: self } + } + #[doc = "Bit 11 - PEC Error flag clear"] + #[inline] + pub fn peccf(&mut self) -> _PECCFW { + _PECCFW { w: self } + } + #[doc = "Bit 12 - Timeout detection flag clear"] + #[inline] + pub fn timoutcf(&mut self) -> _TIMOUTCFW { + _TIMOUTCFW { w: self } + } + #[doc = "Bit 13 - Alert flag clear"] + #[inline] + pub fn alertcf(&mut self) -> _ALERTCFW { + _ALERTCFW { w: self } + } +} diff --git a/src/fmpi2c/isr/mod.rs b/src/fmpi2c/isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c9e6b9e480a985eb80755c2b60d6c6e06882a8d --- /dev/null +++ b/src/fmpi2c/isr/mod.rs @@ -0,0 +1,637 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ISR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXER { + bits: bool, +} +impl TXER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXISR { + bits: bool, +} +impl TXISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNER { + bits: bool, +} +impl RXNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADDRR { + bits: bool, +} +impl ADDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NACKFR { + bits: bool, +} +impl NACKFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPFR { + bits: bool, +} +impl STOPFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCR { + bits: bool, +} +impl TCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCRR { + bits: bool, +} +impl TCRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BERRR { + bits: bool, +} +impl BERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARLOR { + bits: bool, +} +impl ARLOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRR { + bits: bool, +} +impl OVRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PECERRR { + bits: bool, +} +impl PECERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMEOUTR { + bits: bool, +} +impl TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALERTR { + bits: bool, +} +impl ALERTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BUSYR { + bits: bool, +} +impl BUSYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: bool, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADDCODER { + bits: u8, +} +impl ADDCODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TXEW<'a> { + w: &'a mut W, +} +impl<'a> _TXEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXISW<'a> { + w: &'a mut W, +} +impl<'a> _TXISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TXE"] + #[inline] + pub fn txe(&self) -> TXER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXER { bits } + } + #[doc = "Bit 1 - TXIS"] + #[inline] + pub fn txis(&self) -> TXISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXISR { bits } + } + #[doc = "Bit 2 - RXNE"] + #[inline] + pub fn rxne(&self) -> RXNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNER { bits } + } + #[doc = "Bit 3 - ADDR"] + #[inline] + pub fn addr(&self) -> ADDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADDRR { bits } + } + #[doc = "Bit 4 - NACKF"] + #[inline] + pub fn nackf(&self) -> NACKFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NACKFR { bits } + } + #[doc = "Bit 5 - STOPF"] + #[inline] + pub fn stopf(&self) -> STOPFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STOPFR { bits } + } + #[doc = "Bit 6 - TC"] + #[inline] + pub fn tc(&self) -> TCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCR { bits } + } + #[doc = "Bit 7 - TCR"] + #[inline] + pub fn tcr(&self) -> TCRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCRR { bits } + } + #[doc = "Bit 8 - BERR"] + #[inline] + pub fn berr(&self) -> BERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BERRR { bits } + } + #[doc = "Bit 9 - ARLO"] + #[inline] + pub fn arlo(&self) -> ARLOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARLOR { bits } + } + #[doc = "Bit 10 - OVR"] + #[inline] + pub fn ovr(&self) -> OVRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRR { bits } + } + #[doc = "Bit 11 - PECERR"] + #[inline] + pub fn pecerr(&self) -> PECERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PECERRR { bits } + } + #[doc = "Bit 12 - TIMEOUT"] + #[inline] + pub fn timeout(&self) -> TIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIMEOUTR { bits } + } + #[doc = "Bit 13 - ALERT"] + #[inline] + pub fn alert(&self) -> ALERTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALERTR { bits } + } + #[doc = "Bit 15 - BUSY"] + #[inline] + pub fn busy(&self) -> BUSYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BUSYR { bits } + } + #[doc = "Bit 16 - DIR"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DIRR { bits } + } + #[doc = "Bits 17:23 - ADDCODE"] + #[inline] + pub fn addcode(&self) -> ADDCODER { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDCODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TXE"] + #[inline] + pub fn txe(&mut self) -> _TXEW { + _TXEW { w: self } + } + #[doc = "Bit 1 - TXIS"] + #[inline] + pub fn txis(&mut self) -> _TXISW { + _TXISW { w: self } + } +} diff --git a/src/fmpi2c/mod.rs b/src/fmpi2c/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aeda3eb912bea9f72534023adf02c2574e457a7e --- /dev/null +++ b/src/fmpi2c/mod.rs @@ -0,0 +1,92 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Control register 1"] + pub cr1: CR1, + #[doc = "0x04 - Control register 2"] + pub cr2: CR2, + #[doc = "0x08 - Own address register 1"] + pub oar1: OAR1, + #[doc = "0x0c - Own address register 2"] + pub oar2: OAR2, + #[doc = "0x10 - Timing register"] + pub timingr: TIMINGR, + #[doc = "0x14 - Timeout register"] + pub timeoutr: TIMEOUTR, + #[doc = "0x18 - Interrupt and Status register"] + pub isr: ISR, + #[doc = "0x1c - Interrupt clear register"] + pub icr: ICR, + #[doc = "0x20 - PEC register"] + pub pecr: PECR, + #[doc = "0x24 - Receive data register"] + pub rxdr: RXDR, + #[doc = "0x28 - Transmit data register"] + pub txdr: TXDR, +} +#[doc = "Control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 1"] +pub mod cr1; +#[doc = "Control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 2"] +pub mod cr2; +#[doc = "Own address register 1"] +pub struct OAR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Own address register 1"] +pub mod oar1; +#[doc = "Own address register 2"] +pub struct OAR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Own address register 2"] +pub mod oar2; +#[doc = "Timing register"] +pub struct TIMINGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Timing register"] +pub mod timingr; +#[doc = "Timeout register"] +pub struct TIMEOUTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Timeout register"] +pub mod timeoutr; +#[doc = "Interrupt and Status register"] +pub struct ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt and Status register"] +pub mod isr; +#[doc = "Interrupt clear register"] +pub struct ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt clear register"] +pub mod icr; +#[doc = "PEC register"] +pub struct PECR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PEC register"] +pub mod pecr; +#[doc = "Receive data register"] +pub struct RXDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Receive data register"] +pub mod rxdr; +#[doc = "Transmit data register"] +pub struct TXDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Transmit data register"] +pub mod txdr; diff --git a/src/fmpi2c/oar1/mod.rs b/src/fmpi2c/oar1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bd08fed52b3ac692abd7e9a2a3170a28e4f35b8c --- /dev/null +++ b/src/fmpi2c/oar1/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OAR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OA1R { + bits: bool, +} +impl OA1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OA11_7R { + bits: u8, +} +impl OA11_7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OA18_9R { + bits: u8, +} +impl OA18_9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OA1MODER { + bits: bool, +} +impl OA1MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OA1ENR { + bits: bool, +} +impl OA1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OA1W<'a> { + w: &'a mut W, +} +impl<'a> _OA1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA11_7W<'a> { + w: &'a mut W, +} +impl<'a> _OA11_7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA18_9W<'a> { + w: &'a mut W, +} +impl<'a> _OA18_9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA1MODEW<'a> { + w: &'a mut W, +} +impl<'a> _OA1MODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA1ENW<'a> { + w: &'a mut W, +} +impl<'a> _OA1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - OA1"] + #[inline] + pub fn oa1(&self) -> OA1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OA1R { bits } + } + #[doc = "Bits 1:7 - OA11_7"] + #[inline] + pub fn oa11_7(&self) -> OA11_7R { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OA11_7R { bits } + } + #[doc = "Bits 8:9 - OA18_9"] + #[inline] + pub fn oa18_9(&self) -> OA18_9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OA18_9R { bits } + } + #[doc = "Bit 10 - OA1MODE"] + #[inline] + pub fn oa1mode(&self) -> OA1MODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OA1MODER { bits } + } + #[doc = "Bit 15 - OA1EN"] + #[inline] + pub fn oa1en(&self) -> OA1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OA1ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - OA1"] + #[inline] + pub fn oa1(&mut self) -> _OA1W { + _OA1W { w: self } + } + #[doc = "Bits 1:7 - OA11_7"] + #[inline] + pub fn oa11_7(&mut self) -> _OA11_7W { + _OA11_7W { w: self } + } + #[doc = "Bits 8:9 - OA18_9"] + #[inline] + pub fn oa18_9(&mut self) -> _OA18_9W { + _OA18_9W { w: self } + } + #[doc = "Bit 10 - OA1MODE"] + #[inline] + pub fn oa1mode(&mut self) -> _OA1MODEW { + _OA1MODEW { w: self } + } + #[doc = "Bit 15 - OA1EN"] + #[inline] + pub fn oa1en(&mut self) -> _OA1ENW { + _OA1ENW { w: self } + } +} diff --git a/src/fmpi2c/oar2/mod.rs b/src/fmpi2c/oar2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..718c86f9515349633f39a5e7354b56c7e7f28f09 --- /dev/null +++ b/src/fmpi2c/oar2/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OAR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OA21_7R { + bits: u8, +} +impl OA21_7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OA2MSKR { + bits: u8, +} +impl OA2MSKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OA2ENR { + bits: bool, +} +impl OA2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OA21_7W<'a> { + w: &'a mut W, +} +impl<'a> _OA21_7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA2MSKW<'a> { + w: &'a mut W, +} +impl<'a> _OA2MSKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OA2ENW<'a> { + w: &'a mut W, +} +impl<'a> _OA2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 1:7 - OA21_7"] + #[inline] + pub fn oa21_7(&self) -> OA21_7R { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OA21_7R { bits } + } + #[doc = "Bits 8:10 - OA2MSK"] + #[inline] + pub fn oa2msk(&self) -> OA2MSKR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OA2MSKR { bits } + } + #[doc = "Bit 15 - OA2EN"] + #[inline] + pub fn oa2en(&self) -> OA2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OA2ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 1:7 - OA21_7"] + #[inline] + pub fn oa21_7(&mut self) -> _OA21_7W { + _OA21_7W { w: self } + } + #[doc = "Bits 8:10 - OA2MSK"] + #[inline] + pub fn oa2msk(&mut self) -> _OA2MSKW { + _OA2MSKW { w: self } + } + #[doc = "Bit 15 - OA2EN"] + #[inline] + pub fn oa2en(&mut self) -> _OA2ENW { + _OA2ENW { w: self } + } +} diff --git a/src/fmpi2c/pecr/mod.rs b/src/fmpi2c/pecr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5d4a1852a3d68fdfb53cbea9ba5028593f20b8ff --- /dev/null +++ b/src/fmpi2c/pecr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::PECR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct PECR { + bits: u8, +} +impl PECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - PEC"] + #[inline] + pub fn pec(&self) -> PECR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PECR { bits } + } +} diff --git a/src/fmpi2c/rxdr/mod.rs b/src/fmpi2c/rxdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1825a7f01df92de1307850a8a64c4815d01e11a0 --- /dev/null +++ b/src/fmpi2c/rxdr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RXDR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RXDATAR { + bits: u8, +} +impl RXDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - RXDATA"] + #[inline] + pub fn rxdata(&self) -> RXDATAR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RXDATAR { bits } + } +} diff --git a/src/fmpi2c/timeoutr/mod.rs b/src/fmpi2c/timeoutr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eef6f5bd8e5284b28023b5cb0fcf93a49b475596 --- /dev/null +++ b/src/fmpi2c/timeoutr/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TIMEOUTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIMEOUTAR { + bits: u16, +} +impl TIMEOUTAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TIDLER { + bits: bool, +} +impl TIDLER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMOUTENR { + bits: bool, +} +impl TIMOUTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMEOUTBR { + bits: u16, +} +impl TIMEOUTBR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TEXTENR { + bits: bool, +} +impl TEXTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIMEOUTAW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEOUTAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIDLEW<'a> { + w: &'a mut W, +} +impl<'a> _TIDLEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMOUTENW<'a> { + w: &'a mut W, +} +impl<'a> _TIMOUTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMEOUTBW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEOUTBW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEXTENW<'a> { + w: &'a mut W, +} +impl<'a> _TEXTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - TIMEOUTA"] + #[inline] + pub fn timeouta(&self) -> TIMEOUTAR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMEOUTAR { bits } + } + #[doc = "Bit 12 - TIDLE"] + #[inline] + pub fn tidle(&self) -> TIDLER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIDLER { bits } + } + #[doc = "Bit 15 - TIMOUTEN"] + #[inline] + pub fn timouten(&self) -> TIMOUTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIMOUTENR { bits } + } + #[doc = "Bits 16:27 - TIMEOUTB"] + #[inline] + pub fn timeoutb(&self) -> TIMEOUTBR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMEOUTBR { bits } + } + #[doc = "Bit 31 - TEXTEN"] + #[inline] + pub fn texten(&self) -> TEXTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEXTENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - TIMEOUTA"] + #[inline] + pub fn timeouta(&mut self) -> _TIMEOUTAW { + _TIMEOUTAW { w: self } + } + #[doc = "Bit 12 - TIDLE"] + #[inline] + pub fn tidle(&mut self) -> _TIDLEW { + _TIDLEW { w: self } + } + #[doc = "Bit 15 - TIMOUTEN"] + #[inline] + pub fn timouten(&mut self) -> _TIMOUTENW { + _TIMOUTENW { w: self } + } + #[doc = "Bits 16:27 - TIMEOUTB"] + #[inline] + pub fn timeoutb(&mut self) -> _TIMEOUTBW { + _TIMEOUTBW { w: self } + } + #[doc = "Bit 31 - TEXTEN"] + #[inline] + pub fn texten(&mut self) -> _TEXTENW { + _TEXTENW { w: self } + } +} diff --git a/src/fmpi2c/timingr/mod.rs b/src/fmpi2c/timingr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e2413d53af032f89a70b214bf25c61c849ca75c6 --- /dev/null +++ b/src/fmpi2c/timingr/mod.rs @@ -0,0 +1,269 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TIMINGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SCLLR { + bits: u8, +} +impl SCLLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCLHR { + bits: u8, +} +impl SCLHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SDADELR { + bits: u8, +} +impl SDADELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SCLDELR { + bits: u8, +} +impl SCLDELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PRESCR { + bits: u8, +} +impl PRESCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SCLLW<'a> { + w: &'a mut W, +} +impl<'a> _SCLLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCLHW<'a> { + w: &'a mut W, +} +impl<'a> _SCLHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDADELW<'a> { + w: &'a mut W, +} +impl<'a> _SDADELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCLDELW<'a> { + w: &'a mut W, +} +impl<'a> _SCLDELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRESCW<'a> { + w: &'a mut W, +} +impl<'a> _PRESCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - SCLL"] + #[inline] + pub fn scll(&self) -> SCLLR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCLLR { bits } + } + #[doc = "Bits 8:15 - SCLH"] + #[inline] + pub fn sclh(&self) -> SCLHR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCLHR { bits } + } + #[doc = "Bits 16:19 - SDADEL"] + #[inline] + pub fn sdadel(&self) -> SDADELR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SDADELR { bits } + } + #[doc = "Bits 20:23 - SCLDEL"] + #[inline] + pub fn scldel(&self) -> SCLDELR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SCLDELR { bits } + } + #[doc = "Bits 28:31 - PRESC"] + #[inline] + pub fn presc(&self) -> PRESCR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRESCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - SCLL"] + #[inline] + pub fn scll(&mut self) -> _SCLLW { + _SCLLW { w: self } + } + #[doc = "Bits 8:15 - SCLH"] + #[inline] + pub fn sclh(&mut self) -> _SCLHW { + _SCLHW { w: self } + } + #[doc = "Bits 16:19 - SDADEL"] + #[inline] + pub fn sdadel(&mut self) -> _SDADELW { + _SDADELW { w: self } + } + #[doc = "Bits 20:23 - SCLDEL"] + #[inline] + pub fn scldel(&mut self) -> _SCLDELW { + _SCLDELW { w: self } + } + #[doc = "Bits 28:31 - PRESC"] + #[inline] + pub fn presc(&mut self) -> _PRESCW { + _PRESCW { w: self } + } +} diff --git a/src/fmpi2c/txdr/mod.rs b/src/fmpi2c/txdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ad674cc2f832c9ddb5b0227d287b7cf219b8aafc --- /dev/null +++ b/src/fmpi2c/txdr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TXDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXDATAR { + bits: u8, +} +impl TXDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TXDATAW<'a> { + w: &'a mut W, +} +impl<'a> _TXDATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - TXDATA"] + #[inline] + pub fn txdata(&self) -> TXDATAR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXDATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - TXDATA"] + #[inline] + pub fn txdata(&mut self) -> _TXDATAW { + _TXDATAW { w: self } + } +} diff --git a/src/fsmc/bcr1/mod.rs b/src/fsmc/bcr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dbd36339c97b3c9037390d175398ee8b4647f630 --- /dev/null +++ b/src/fsmc/bcr1/mod.rs @@ -0,0 +1,795 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CBURSTRWR { + bits: bool, +} +impl CBURSTRWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ASYNCWAITR { + bits: bool, +} +impl ASYNCWAITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTMODR { + bits: bool, +} +impl EXTMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITENR { + bits: bool, +} +impl WAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRENR { + bits: bool, +} +impl WRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITCFGR { + bits: bool, +} +impl WAITCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITPOLR { + bits: bool, +} +impl WAITPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BURSTENR { + bits: bool, +} +impl BURSTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACCENR { + bits: bool, +} +impl FACCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MWIDR { + bits: u8, +} +impl MWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTYPR { + bits: u8, +} +impl MTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUXENR { + bits: bool, +} +impl MUXENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MBKENR { + bits: bool, +} +impl MBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CBURSTRWW<'a> { + w: &'a mut W, +} +impl<'a> _CBURSTRWW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ASYNCWAITW<'a> { + w: &'a mut W, +} +impl<'a> _ASYNCWAITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTMODW<'a> { + w: &'a mut W, +} +impl<'a> _EXTMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITENW<'a> { + w: &'a mut W, +} +impl<'a> _WAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRENW<'a> { + w: &'a mut W, +} +impl<'a> _WRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WAITCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITPOLW<'a> { + w: &'a mut W, +} +impl<'a> _WAITPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BURSTENW<'a> { + w: &'a mut W, +} +impl<'a> _BURSTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACCENW<'a> { + w: &'a mut W, +} +impl<'a> _FACCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MWIDW<'a> { + w: &'a mut W, +} +impl<'a> _MWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MTYPW<'a> { + w: &'a mut W, +} +impl<'a> _MTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUXENW<'a> { + w: &'a mut W, +} +impl<'a> _MUXENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBKENW<'a> { + w: &'a mut W, +} +impl<'a> _MBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&self) -> CBURSTRWR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CBURSTRWR { bits } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&self) -> ASYNCWAITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ASYNCWAITR { bits } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&self) -> EXTMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTMODR { bits } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&self) -> WAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITENR { bits } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&self) -> WRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRENR { bits } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&self) -> WAITCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITCFGR { bits } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&self) -> WAITPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITPOLR { bits } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&self) -> BURSTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BURSTENR { bits } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&self) -> FACCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACCENR { bits } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&self) -> MWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MWIDR { bits } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&self) -> MTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MTYPR { bits } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&self) -> MUXENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUXENR { bits } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&self) -> MBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MBKENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 12496 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&mut self) -> _CBURSTRWW { + _CBURSTRWW { w: self } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&mut self) -> _ASYNCWAITW { + _ASYNCWAITW { w: self } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&mut self) -> _EXTMODW { + _EXTMODW { w: self } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&mut self) -> _WAITENW { + _WAITENW { w: self } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&mut self) -> _WRENW { + _WRENW { w: self } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&mut self) -> _WAITCFGW { + _WAITCFGW { w: self } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&mut self) -> _WAITPOLW { + _WAITPOLW { w: self } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&mut self) -> _BURSTENW { + _BURSTENW { w: self } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&mut self) -> _FACCENW { + _FACCENW { w: self } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&mut self) -> _MWIDW { + _MWIDW { w: self } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&mut self) -> _MTYPW { + _MTYPW { w: self } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&mut self) -> _MUXENW { + _MUXENW { w: self } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&mut self) -> _MBKENW { + _MBKENW { w: self } + } +} diff --git a/src/fsmc/bcr2/mod.rs b/src/fsmc/bcr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..440b644b01bfd12d913323da319735a4c0847f61 --- /dev/null +++ b/src/fsmc/bcr2/mod.rs @@ -0,0 +1,854 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CBURSTRWR { + bits: bool, +} +impl CBURSTRWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ASYNCWAITR { + bits: bool, +} +impl ASYNCWAITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTMODR { + bits: bool, +} +impl EXTMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITENR { + bits: bool, +} +impl WAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRENR { + bits: bool, +} +impl WRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITCFGR { + bits: bool, +} +impl WAITCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRAPMODR { + bits: bool, +} +impl WRAPMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITPOLR { + bits: bool, +} +impl WAITPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BURSTENR { + bits: bool, +} +impl BURSTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACCENR { + bits: bool, +} +impl FACCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MWIDR { + bits: u8, +} +impl MWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTYPR { + bits: u8, +} +impl MTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUXENR { + bits: bool, +} +impl MUXENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MBKENR { + bits: bool, +} +impl MBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CBURSTRWW<'a> { + w: &'a mut W, +} +impl<'a> _CBURSTRWW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ASYNCWAITW<'a> { + w: &'a mut W, +} +impl<'a> _ASYNCWAITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTMODW<'a> { + w: &'a mut W, +} +impl<'a> _EXTMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITENW<'a> { + w: &'a mut W, +} +impl<'a> _WAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRENW<'a> { + w: &'a mut W, +} +impl<'a> _WRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WAITCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRAPMODW<'a> { + w: &'a mut W, +} +impl<'a> _WRAPMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITPOLW<'a> { + w: &'a mut W, +} +impl<'a> _WAITPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BURSTENW<'a> { + w: &'a mut W, +} +impl<'a> _BURSTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACCENW<'a> { + w: &'a mut W, +} +impl<'a> _FACCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MWIDW<'a> { + w: &'a mut W, +} +impl<'a> _MWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MTYPW<'a> { + w: &'a mut W, +} +impl<'a> _MTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUXENW<'a> { + w: &'a mut W, +} +impl<'a> _MUXENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBKENW<'a> { + w: &'a mut W, +} +impl<'a> _MBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&self) -> CBURSTRWR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CBURSTRWR { bits } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&self) -> ASYNCWAITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ASYNCWAITR { bits } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&self) -> EXTMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTMODR { bits } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&self) -> WAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITENR { bits } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&self) -> WRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRENR { bits } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&self) -> WAITCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITCFGR { bits } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&self) -> WRAPMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRAPMODR { bits } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&self) -> WAITPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITPOLR { bits } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&self) -> BURSTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BURSTENR { bits } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&self) -> FACCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACCENR { bits } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&self) -> MWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MWIDR { bits } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&self) -> MTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MTYPR { bits } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&self) -> MUXENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUXENR { bits } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&self) -> MBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MBKENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 12496 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&mut self) -> _CBURSTRWW { + _CBURSTRWW { w: self } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&mut self) -> _ASYNCWAITW { + _ASYNCWAITW { w: self } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&mut self) -> _EXTMODW { + _EXTMODW { w: self } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&mut self) -> _WAITENW { + _WAITENW { w: self } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&mut self) -> _WRENW { + _WRENW { w: self } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&mut self) -> _WAITCFGW { + _WAITCFGW { w: self } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&mut self) -> _WRAPMODW { + _WRAPMODW { w: self } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&mut self) -> _WAITPOLW { + _WAITPOLW { w: self } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&mut self) -> _BURSTENW { + _BURSTENW { w: self } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&mut self) -> _FACCENW { + _FACCENW { w: self } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&mut self) -> _MWIDW { + _MWIDW { w: self } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&mut self) -> _MTYPW { + _MTYPW { w: self } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&mut self) -> _MUXENW { + _MUXENW { w: self } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&mut self) -> _MBKENW { + _MBKENW { w: self } + } +} diff --git a/src/fsmc/bcr3/mod.rs b/src/fsmc/bcr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..42d66364b431c00e7fb597d9df88c8227ea252b6 --- /dev/null +++ b/src/fsmc/bcr3/mod.rs @@ -0,0 +1,854 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CBURSTRWR { + bits: bool, +} +impl CBURSTRWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ASYNCWAITR { + bits: bool, +} +impl ASYNCWAITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTMODR { + bits: bool, +} +impl EXTMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITENR { + bits: bool, +} +impl WAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRENR { + bits: bool, +} +impl WRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITCFGR { + bits: bool, +} +impl WAITCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRAPMODR { + bits: bool, +} +impl WRAPMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITPOLR { + bits: bool, +} +impl WAITPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BURSTENR { + bits: bool, +} +impl BURSTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACCENR { + bits: bool, +} +impl FACCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MWIDR { + bits: u8, +} +impl MWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTYPR { + bits: u8, +} +impl MTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUXENR { + bits: bool, +} +impl MUXENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MBKENR { + bits: bool, +} +impl MBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CBURSTRWW<'a> { + w: &'a mut W, +} +impl<'a> _CBURSTRWW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ASYNCWAITW<'a> { + w: &'a mut W, +} +impl<'a> _ASYNCWAITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTMODW<'a> { + w: &'a mut W, +} +impl<'a> _EXTMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITENW<'a> { + w: &'a mut W, +} +impl<'a> _WAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRENW<'a> { + w: &'a mut W, +} +impl<'a> _WRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WAITCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRAPMODW<'a> { + w: &'a mut W, +} +impl<'a> _WRAPMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITPOLW<'a> { + w: &'a mut W, +} +impl<'a> _WAITPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BURSTENW<'a> { + w: &'a mut W, +} +impl<'a> _BURSTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACCENW<'a> { + w: &'a mut W, +} +impl<'a> _FACCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MWIDW<'a> { + w: &'a mut W, +} +impl<'a> _MWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MTYPW<'a> { + w: &'a mut W, +} +impl<'a> _MTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUXENW<'a> { + w: &'a mut W, +} +impl<'a> _MUXENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBKENW<'a> { + w: &'a mut W, +} +impl<'a> _MBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&self) -> CBURSTRWR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CBURSTRWR { bits } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&self) -> ASYNCWAITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ASYNCWAITR { bits } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&self) -> EXTMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTMODR { bits } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&self) -> WAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITENR { bits } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&self) -> WRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRENR { bits } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&self) -> WAITCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITCFGR { bits } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&self) -> WRAPMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRAPMODR { bits } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&self) -> WAITPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITPOLR { bits } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&self) -> BURSTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BURSTENR { bits } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&self) -> FACCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACCENR { bits } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&self) -> MWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MWIDR { bits } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&self) -> MTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MTYPR { bits } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&self) -> MUXENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUXENR { bits } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&self) -> MBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MBKENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 12496 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&mut self) -> _CBURSTRWW { + _CBURSTRWW { w: self } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&mut self) -> _ASYNCWAITW { + _ASYNCWAITW { w: self } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&mut self) -> _EXTMODW { + _EXTMODW { w: self } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&mut self) -> _WAITENW { + _WAITENW { w: self } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&mut self) -> _WRENW { + _WRENW { w: self } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&mut self) -> _WAITCFGW { + _WAITCFGW { w: self } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&mut self) -> _WRAPMODW { + _WRAPMODW { w: self } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&mut self) -> _WAITPOLW { + _WAITPOLW { w: self } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&mut self) -> _BURSTENW { + _BURSTENW { w: self } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&mut self) -> _FACCENW { + _FACCENW { w: self } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&mut self) -> _MWIDW { + _MWIDW { w: self } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&mut self) -> _MTYPW { + _MTYPW { w: self } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&mut self) -> _MUXENW { + _MUXENW { w: self } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&mut self) -> _MBKENW { + _MBKENW { w: self } + } +} diff --git a/src/fsmc/bcr4/mod.rs b/src/fsmc/bcr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..470b8d99f8d8a89330c05810791a4c9ed2c2a78b --- /dev/null +++ b/src/fsmc/bcr4/mod.rs @@ -0,0 +1,854 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CBURSTRWR { + bits: bool, +} +impl CBURSTRWR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ASYNCWAITR { + bits: bool, +} +impl ASYNCWAITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTMODR { + bits: bool, +} +impl EXTMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITENR { + bits: bool, +} +impl WAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRENR { + bits: bool, +} +impl WRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITCFGR { + bits: bool, +} +impl WAITCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WRAPMODR { + bits: bool, +} +impl WRAPMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITPOLR { + bits: bool, +} +impl WAITPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BURSTENR { + bits: bool, +} +impl BURSTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FACCENR { + bits: bool, +} +impl FACCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MWIDR { + bits: u8, +} +impl MWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTYPR { + bits: u8, +} +impl MTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUXENR { + bits: bool, +} +impl MUXENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MBKENR { + bits: bool, +} +impl MBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CBURSTRWW<'a> { + w: &'a mut W, +} +impl<'a> _CBURSTRWW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ASYNCWAITW<'a> { + w: &'a mut W, +} +impl<'a> _ASYNCWAITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTMODW<'a> { + w: &'a mut W, +} +impl<'a> _EXTMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITENW<'a> { + w: &'a mut W, +} +impl<'a> _WAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRENW<'a> { + w: &'a mut W, +} +impl<'a> _WRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WAITCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WRAPMODW<'a> { + w: &'a mut W, +} +impl<'a> _WRAPMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITPOLW<'a> { + w: &'a mut W, +} +impl<'a> _WAITPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BURSTENW<'a> { + w: &'a mut W, +} +impl<'a> _BURSTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FACCENW<'a> { + w: &'a mut W, +} +impl<'a> _FACCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MWIDW<'a> { + w: &'a mut W, +} +impl<'a> _MWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MTYPW<'a> { + w: &'a mut W, +} +impl<'a> _MTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUXENW<'a> { + w: &'a mut W, +} +impl<'a> _MUXENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MBKENW<'a> { + w: &'a mut W, +} +impl<'a> _MBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&self) -> CBURSTRWR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CBURSTRWR { bits } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&self) -> ASYNCWAITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ASYNCWAITR { bits } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&self) -> EXTMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTMODR { bits } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&self) -> WAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITENR { bits } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&self) -> WRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRENR { bits } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&self) -> WAITCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITCFGR { bits } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&self) -> WRAPMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WRAPMODR { bits } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&self) -> WAITPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITPOLR { bits } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&self) -> BURSTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BURSTENR { bits } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&self) -> FACCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FACCENR { bits } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&self) -> MWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MWIDR { bits } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&self) -> MTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MTYPR { bits } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&self) -> MUXENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUXENR { bits } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&self) -> MBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MBKENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 12496 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 19 - CBURSTRW"] + #[inline] + pub fn cburstrw(&mut self) -> _CBURSTRWW { + _CBURSTRWW { w: self } + } + #[doc = "Bit 15 - ASYNCWAIT"] + #[inline] + pub fn asyncwait(&mut self) -> _ASYNCWAITW { + _ASYNCWAITW { w: self } + } + #[doc = "Bit 14 - EXTMOD"] + #[inline] + pub fn extmod(&mut self) -> _EXTMODW { + _EXTMODW { w: self } + } + #[doc = "Bit 13 - WAITEN"] + #[inline] + pub fn waiten(&mut self) -> _WAITENW { + _WAITENW { w: self } + } + #[doc = "Bit 12 - WREN"] + #[inline] + pub fn wren(&mut self) -> _WRENW { + _WRENW { w: self } + } + #[doc = "Bit 11 - WAITCFG"] + #[inline] + pub fn waitcfg(&mut self) -> _WAITCFGW { + _WAITCFGW { w: self } + } + #[doc = "Bit 10 - WRAPMOD"] + #[inline] + pub fn wrapmod(&mut self) -> _WRAPMODW { + _WRAPMODW { w: self } + } + #[doc = "Bit 9 - WAITPOL"] + #[inline] + pub fn waitpol(&mut self) -> _WAITPOLW { + _WAITPOLW { w: self } + } + #[doc = "Bit 8 - BURSTEN"] + #[inline] + pub fn bursten(&mut self) -> _BURSTENW { + _BURSTENW { w: self } + } + #[doc = "Bit 6 - FACCEN"] + #[inline] + pub fn faccen(&mut self) -> _FACCENW { + _FACCENW { w: self } + } + #[doc = "Bits 4:5 - MWID"] + #[inline] + pub fn mwid(&mut self) -> _MWIDW { + _MWIDW { w: self } + } + #[doc = "Bits 2:3 - MTYP"] + #[inline] + pub fn mtyp(&mut self) -> _MTYPW { + _MTYPW { w: self } + } + #[doc = "Bit 1 - MUXEN"] + #[inline] + pub fn muxen(&mut self) -> _MUXENW { + _MUXENW { w: self } + } + #[doc = "Bit 0 - MBKEN"] + #[inline] + pub fn mbken(&mut self) -> _MBKENW { + _MBKENW { w: self } + } +} diff --git a/src/fsmc/btr1/mod.rs b/src/fsmc/btr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..09805011be1401eda2848b6b8d0f680e1b65eabd --- /dev/null +++ b/src/fsmc/btr1/mod.rs @@ -0,0 +1,351 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BTR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BUSTURNR { + bits: u8, +} +impl BUSTURNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BUSTURNW<'a> { + w: &'a mut W, +} +impl<'a> _BUSTURNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&self) -> BUSTURNR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BUSTURNR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4294967295 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&mut self) -> _BUSTURNW { + _BUSTURNW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/btr2/mod.rs b/src/fsmc/btr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1577ef050a2808ba95b6ba009a3d4027293fddf0 --- /dev/null +++ b/src/fsmc/btr2/mod.rs @@ -0,0 +1,351 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BTR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BUSTURNR { + bits: u8, +} +impl BUSTURNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BUSTURNW<'a> { + w: &'a mut W, +} +impl<'a> _BUSTURNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&self) -> BUSTURNR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BUSTURNR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4294967295 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&mut self) -> _BUSTURNW { + _BUSTURNW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/btr3/mod.rs b/src/fsmc/btr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..38ea46026868e832de2bac53c3d9caaf8471986d --- /dev/null +++ b/src/fsmc/btr3/mod.rs @@ -0,0 +1,351 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BTR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BUSTURNR { + bits: u8, +} +impl BUSTURNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BUSTURNW<'a> { + w: &'a mut W, +} +impl<'a> _BUSTURNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&self) -> BUSTURNR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BUSTURNR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4294967295 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&mut self) -> _BUSTURNW { + _BUSTURNW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/btr4/mod.rs b/src/fsmc/btr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8c69b78bf461f2344d294cea9e35e2163da503cc --- /dev/null +++ b/src/fsmc/btr4/mod.rs @@ -0,0 +1,351 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BTR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BUSTURNR { + bits: u8, +} +impl BUSTURNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BUSTURNW<'a> { + w: &'a mut W, +} +impl<'a> _BUSTURNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&self) -> BUSTURNR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BUSTURNR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4294967295 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 16:19 - BUSTURN"] + #[inline] + pub fn busturn(&mut self) -> _BUSTURNW { + _BUSTURNW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/bwtr1/mod.rs b/src/fsmc/bwtr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..01842ff02a800122c1419d63931b424dc7ccab3a --- /dev/null +++ b/src/fsmc/bwtr1/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BWTR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 268435455 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/bwtr2/mod.rs b/src/fsmc/bwtr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..af738d6325fbdca69e9ec11ac0558a837d419445 --- /dev/null +++ b/src/fsmc/bwtr2/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BWTR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 268435455 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/bwtr3/mod.rs b/src/fsmc/bwtr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9af7733b4e490fe828c55abc32223323884dfce3 --- /dev/null +++ b/src/fsmc/bwtr3/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BWTR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 268435455 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/bwtr4/mod.rs b/src/fsmc/bwtr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c0011e83387548d724af79791e017ceb32fb646d --- /dev/null +++ b/src/fsmc/bwtr4/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BWTR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ACCMODR { + bits: u8, +} +impl ACCMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATLATR { + bits: u8, +} +impl DATLATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DATASTR { + bits: u8, +} +impl DATASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDHLDR { + bits: u8, +} +impl ADDHLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADDSETR { + bits: u8, +} +impl ADDSETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ACCMODW<'a> { + w: &'a mut W, +} +impl<'a> _ACCMODW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLATW<'a> { + w: &'a mut W, +} +impl<'a> _DATLATW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATASTW<'a> { + w: &'a mut W, +} +impl<'a> _DATASTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDHLDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDHLDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDSETW<'a> { + w: &'a mut W, +} +impl<'a> _ADDSETW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&self) -> ACCMODR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ACCMODR { bits } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&self) -> DATLATR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLATR { bits } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&self) -> DATASTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATASTR { bits } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&self) -> ADDHLDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDHLDR { bits } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&self) -> ADDSETR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDSETR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 268435455 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:29 - ACCMOD"] + #[inline] + pub fn accmod(&mut self) -> _ACCMODW { + _ACCMODW { w: self } + } + #[doc = "Bits 24:27 - DATLAT"] + #[inline] + pub fn datlat(&mut self) -> _DATLATW { + _DATLATW { w: self } + } + #[doc = "Bits 20:23 - CLKDIV"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } + #[doc = "Bits 8:15 - DATAST"] + #[inline] + pub fn datast(&mut self) -> _DATASTW { + _DATASTW { w: self } + } + #[doc = "Bits 4:7 - ADDHLD"] + #[inline] + pub fn addhld(&mut self) -> _ADDHLDW { + _ADDHLDW { w: self } + } + #[doc = "Bits 0:3 - ADDSET"] + #[inline] + pub fn addset(&mut self) -> _ADDSETW { + _ADDSETW { w: self } + } +} diff --git a/src/fsmc/eccr2/mod.rs b/src/fsmc/eccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b3d1f4b40dd80d818cee1a9374f4caeae1bd1e73 --- /dev/null +++ b/src/fsmc/eccr2/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::ECCR2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct ECCXR { + bits: u32, +} +impl ECCXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - ECCx"] + #[inline] + pub fn eccx(&self) -> ECCXR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + ECCXR { bits } + } +} diff --git a/src/fsmc/eccr3/mod.rs b/src/fsmc/eccr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..41b18a64d1f388bd59a3af56426fa2bc7a2b756e --- /dev/null +++ b/src/fsmc/eccr3/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::ECCR3 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct ECCXR { + bits: u32, +} +impl ECCXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - ECCx"] + #[inline] + pub fn eccx(&self) -> ECCXR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + ECCXR { bits } + } +} diff --git a/src/fsmc/mod.rs b/src/fsmc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9335195cad403eb771d5477d7347b6ca190ac982 --- /dev/null +++ b/src/fsmc/mod.rs @@ -0,0 +1,229 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - SRAM/NOR-Flash chip-select control register 1"] + pub bcr1: BCR1, + #[doc = "0x04 - SRAM/NOR-Flash chip-select timing register 1"] + pub btr1: BTR1, + #[doc = "0x08 - SRAM/NOR-Flash chip-select control register 2"] + pub bcr2: BCR2, + #[doc = "0x0c - SRAM/NOR-Flash chip-select timing register 2"] + pub btr2: BTR2, + #[doc = "0x10 - SRAM/NOR-Flash chip-select control register 3"] + pub bcr3: BCR3, + #[doc = "0x14 - SRAM/NOR-Flash chip-select timing register 3"] + pub btr3: BTR3, + #[doc = "0x18 - SRAM/NOR-Flash chip-select control register 4"] + pub bcr4: BCR4, + #[doc = "0x1c - SRAM/NOR-Flash chip-select timing register 4"] + pub btr4: BTR4, + _reserved0: [u8; 64usize], + #[doc = "0x60 - PC Card/NAND Flash control register 2"] + pub pcr2: PCR2, + #[doc = "0x64 - FIFO status and interrupt register 2"] + pub sr2: SR2, + #[doc = "0x68 - Common memory space timing register 2"] + pub pmem2: PMEM2, + #[doc = "0x6c - Attribute memory space timing register 2"] + pub patt2: PATT2, + _reserved1: [u8; 4usize], + #[doc = "0x74 - ECC result register 2"] + pub eccr2: ECCR2, + _reserved2: [u8; 8usize], + #[doc = "0x80 - PC Card/NAND Flash control register 3"] + pub pcr3: PCR3, + #[doc = "0x84 - FIFO status and interrupt register 3"] + pub sr3: SR3, + #[doc = "0x88 - Common memory space timing register 3"] + pub pmem3: PMEM3, + #[doc = "0x8c - Attribute memory space timing register 3"] + pub patt3: PATT3, + _reserved3: [u8; 4usize], + #[doc = "0x94 - ECC result register 3"] + pub eccr3: ECCR3, + _reserved4: [u8; 8usize], + #[doc = "0xa0 - PC Card/NAND Flash control register 4"] + pub pcr4: PCR4, + #[doc = "0xa4 - FIFO status and interrupt register 4"] + pub sr4: SR4, + #[doc = "0xa8 - Common memory space timing register 4"] + pub pmem4: PMEM4, + #[doc = "0xac - Attribute memory space timing register 4"] + pub patt4: PATT4, + #[doc = "0xb0 - I/O space timing register 4"] + pub pio4: PIO4, + _reserved5: [u8; 80usize], + #[doc = "0x104 - SRAM/NOR-Flash write timing registers 1"] + pub bwtr1: BWTR1, + _reserved6: [u8; 4usize], + #[doc = "0x10c - SRAM/NOR-Flash write timing registers 2"] + pub bwtr2: BWTR2, + _reserved7: [u8; 4usize], + #[doc = "0x114 - SRAM/NOR-Flash write timing registers 3"] + pub bwtr3: BWTR3, + _reserved8: [u8; 4usize], + #[doc = "0x11c - SRAM/NOR-Flash write timing registers 4"] + pub bwtr4: BWTR4, +} +#[doc = "SRAM/NOR-Flash chip-select control register 1"] +pub struct BCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select control register 1"] +pub mod bcr1; +#[doc = "SRAM/NOR-Flash chip-select timing register 1"] +pub struct BTR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select timing register 1"] +pub mod btr1; +#[doc = "SRAM/NOR-Flash chip-select control register 2"] +pub struct BCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select control register 2"] +pub mod bcr2; +#[doc = "SRAM/NOR-Flash chip-select timing register 2"] +pub struct BTR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select timing register 2"] +pub mod btr2; +#[doc = "SRAM/NOR-Flash chip-select control register 3"] +pub struct BCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select control register 3"] +pub mod bcr3; +#[doc = "SRAM/NOR-Flash chip-select timing register 3"] +pub struct BTR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select timing register 3"] +pub mod btr3; +#[doc = "SRAM/NOR-Flash chip-select control register 4"] +pub struct BCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select control register 4"] +pub mod bcr4; +#[doc = "SRAM/NOR-Flash chip-select timing register 4"] +pub struct BTR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash chip-select timing register 4"] +pub mod btr4; +#[doc = "PC Card/NAND Flash control register 2"] +pub struct PCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PC Card/NAND Flash control register 2"] +pub mod pcr2; +#[doc = "FIFO status and interrupt register 2"] +pub struct SR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "FIFO status and interrupt register 2"] +pub mod sr2; +#[doc = "Common memory space timing register 2"] +pub struct PMEM2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Common memory space timing register 2"] +pub mod pmem2; +#[doc = "Attribute memory space timing register 2"] +pub struct PATT2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Attribute memory space timing register 2"] +pub mod patt2; +#[doc = "ECC result register 2"] +pub struct ECCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "ECC result register 2"] +pub mod eccr2; +#[doc = "PC Card/NAND Flash control register 3"] +pub struct PCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PC Card/NAND Flash control register 3"] +pub mod pcr3; +#[doc = "FIFO status and interrupt register 3"] +pub struct SR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "FIFO status and interrupt register 3"] +pub mod sr3; +#[doc = "Common memory space timing register 3"] +pub struct PMEM3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Common memory space timing register 3"] +pub mod pmem3; +#[doc = "Attribute memory space timing register 3"] +pub struct PATT3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Attribute memory space timing register 3"] +pub mod patt3; +#[doc = "ECC result register 3"] +pub struct ECCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "ECC result register 3"] +pub mod eccr3; +#[doc = "PC Card/NAND Flash control register 4"] +pub struct PCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PC Card/NAND Flash control register 4"] +pub mod pcr4; +#[doc = "FIFO status and interrupt register 4"] +pub struct SR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "FIFO status and interrupt register 4"] +pub mod sr4; +#[doc = "Common memory space timing register 4"] +pub struct PMEM4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Common memory space timing register 4"] +pub mod pmem4; +#[doc = "Attribute memory space timing register 4"] +pub struct PATT4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Attribute memory space timing register 4"] +pub mod patt4; +#[doc = "I/O space timing register 4"] +pub struct PIO4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "I/O space timing register 4"] +pub mod pio4; +#[doc = "SRAM/NOR-Flash write timing registers 1"] +pub struct BWTR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash write timing registers 1"] +pub mod bwtr1; +#[doc = "SRAM/NOR-Flash write timing registers 2"] +pub struct BWTR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash write timing registers 2"] +pub mod bwtr2; +#[doc = "SRAM/NOR-Flash write timing registers 3"] +pub struct BWTR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash write timing registers 3"] +pub mod bwtr3; +#[doc = "SRAM/NOR-Flash write timing registers 4"] +pub struct BWTR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SRAM/NOR-Flash write timing registers 4"] +pub mod bwtr4; diff --git a/src/fsmc/patt2/mod.rs b/src/fsmc/patt2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..10ee97162942f238e669ce7f899ba6d7a1b38f61 --- /dev/null +++ b/src/fsmc/patt2/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PATT2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ATTHIZXR { + bits: u8, +} +impl ATTHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTHOLDXR { + bits: u8, +} +impl ATTHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTWAITXR { + bits: u8, +} +impl ATTWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTSETXR { + bits: u8, +} +impl ATTSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ATTHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTSETXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&self) -> ATTHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHIZXR { bits } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&self) -> ATTHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHOLDXR { bits } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&self) -> ATTWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTWAITXR { bits } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&self) -> ATTSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&mut self) -> _ATTHIZXW { + _ATTHIZXW { w: self } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&mut self) -> _ATTHOLDXW { + _ATTHOLDXW { w: self } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&mut self) -> _ATTWAITXW { + _ATTWAITXW { w: self } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&mut self) -> _ATTSETXW { + _ATTSETXW { w: self } + } +} diff --git a/src/fsmc/patt3/mod.rs b/src/fsmc/patt3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7744bc3f35567654294b9337af04d9d10ba07c28 --- /dev/null +++ b/src/fsmc/patt3/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PATT3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ATTHIZXR { + bits: u8, +} +impl ATTHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTHOLDXR { + bits: u8, +} +impl ATTHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTWAITXR { + bits: u8, +} +impl ATTWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTSETXR { + bits: u8, +} +impl ATTSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ATTHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTSETXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&self) -> ATTHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHIZXR { bits } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&self) -> ATTHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHOLDXR { bits } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&self) -> ATTWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTWAITXR { bits } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&self) -> ATTSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&mut self) -> _ATTHIZXW { + _ATTHIZXW { w: self } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&mut self) -> _ATTHOLDXW { + _ATTHOLDXW { w: self } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&mut self) -> _ATTWAITXW { + _ATTWAITXW { w: self } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&mut self) -> _ATTSETXW { + _ATTSETXW { w: self } + } +} diff --git a/src/fsmc/patt4/mod.rs b/src/fsmc/patt4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..67e2413e9be5fdc8c2cb3b0645d91cee1ad0d69d --- /dev/null +++ b/src/fsmc/patt4/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PATT4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ATTHIZXR { + bits: u8, +} +impl ATTHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTHOLDXR { + bits: u8, +} +impl ATTHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTWAITXR { + bits: u8, +} +impl ATTWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ATTSETXR { + bits: u8, +} +impl ATTSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ATTHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ATTSETXW<'a> { + w: &'a mut W, +} +impl<'a> _ATTSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&self) -> ATTHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHIZXR { bits } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&self) -> ATTHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTHOLDXR { bits } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&self) -> ATTWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTWAITXR { bits } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&self) -> ATTSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ATTSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - ATTHIZx"] + #[inline] + pub fn atthizx(&mut self) -> _ATTHIZXW { + _ATTHIZXW { w: self } + } + #[doc = "Bits 16:23 - ATTHOLDx"] + #[inline] + pub fn attholdx(&mut self) -> _ATTHOLDXW { + _ATTHOLDXW { w: self } + } + #[doc = "Bits 8:15 - ATTWAITx"] + #[inline] + pub fn attwaitx(&mut self) -> _ATTWAITXW { + _ATTWAITXW { w: self } + } + #[doc = "Bits 0:7 - ATTSETx"] + #[inline] + pub fn attsetx(&mut self) -> _ATTSETXW { + _ATTSETXW { w: self } + } +} diff --git a/src/fsmc/pcr2/mod.rs b/src/fsmc/pcr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e38eb5b08f4017e41dab701bb6af24d4a58dd0b5 --- /dev/null +++ b/src/fsmc/pcr2/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ECCPSR { + bits: u8, +} +impl ECCPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TARR { + bits: u8, +} +impl TARR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TCLRR { + bits: u8, +} +impl TCLRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ECCENR { + bits: bool, +} +impl ECCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWIDR { + bits: u8, +} +impl PWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTYPR { + bits: bool, +} +impl PTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PBKENR { + bits: bool, +} +impl PBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWAITENR { + bits: bool, +} +impl PWAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ECCPSW<'a> { + w: &'a mut W, +} +impl<'a> _ECCPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TARW<'a> { + w: &'a mut W, +} +impl<'a> _TARW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCLRW<'a> { + w: &'a mut W, +} +impl<'a> _TCLRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECCENW<'a> { + w: &'a mut W, +} +impl<'a> _ECCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWIDW<'a> { + w: &'a mut W, +} +impl<'a> _PWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTYPW<'a> { + w: &'a mut W, +} +impl<'a> _PTYPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBKENW<'a> { + w: &'a mut W, +} +impl<'a> _PBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWAITENW<'a> { + w: &'a mut W, +} +impl<'a> _PWAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&self) -> ECCPSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ECCPSR { bits } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&self) -> TARR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TARR { bits } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&self) -> TCLRR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TCLRR { bits } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&self) -> ECCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECCENR { bits } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&self) -> PWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PWIDR { bits } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&self) -> PTYPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTYPR { bits } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&self) -> PBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PBKENR { bits } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&self) -> PWAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWAITENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 24 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&mut self) -> _ECCPSW { + _ECCPSW { w: self } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&mut self) -> _TARW { + _TARW { w: self } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&mut self) -> _TCLRW { + _TCLRW { w: self } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&mut self) -> _ECCENW { + _ECCENW { w: self } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&mut self) -> _PWIDW { + _PWIDW { w: self } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&mut self) -> _PTYPW { + _PTYPW { w: self } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&mut self) -> _PBKENW { + _PBKENW { w: self } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&mut self) -> _PWAITENW { + _PWAITENW { w: self } + } +} diff --git a/src/fsmc/pcr3/mod.rs b/src/fsmc/pcr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..112208e62f7148c89e778628d321658494bfea4d --- /dev/null +++ b/src/fsmc/pcr3/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ECCPSR { + bits: u8, +} +impl ECCPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TARR { + bits: u8, +} +impl TARR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TCLRR { + bits: u8, +} +impl TCLRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ECCENR { + bits: bool, +} +impl ECCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWIDR { + bits: u8, +} +impl PWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTYPR { + bits: bool, +} +impl PTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PBKENR { + bits: bool, +} +impl PBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWAITENR { + bits: bool, +} +impl PWAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ECCPSW<'a> { + w: &'a mut W, +} +impl<'a> _ECCPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TARW<'a> { + w: &'a mut W, +} +impl<'a> _TARW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCLRW<'a> { + w: &'a mut W, +} +impl<'a> _TCLRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECCENW<'a> { + w: &'a mut W, +} +impl<'a> _ECCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWIDW<'a> { + w: &'a mut W, +} +impl<'a> _PWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTYPW<'a> { + w: &'a mut W, +} +impl<'a> _PTYPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBKENW<'a> { + w: &'a mut W, +} +impl<'a> _PBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWAITENW<'a> { + w: &'a mut W, +} +impl<'a> _PWAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&self) -> ECCPSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ECCPSR { bits } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&self) -> TARR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TARR { bits } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&self) -> TCLRR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TCLRR { bits } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&self) -> ECCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECCENR { bits } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&self) -> PWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PWIDR { bits } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&self) -> PTYPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTYPR { bits } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&self) -> PBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PBKENR { bits } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&self) -> PWAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWAITENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 24 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&mut self) -> _ECCPSW { + _ECCPSW { w: self } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&mut self) -> _TARW { + _TARW { w: self } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&mut self) -> _TCLRW { + _TCLRW { w: self } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&mut self) -> _ECCENW { + _ECCENW { w: self } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&mut self) -> _PWIDW { + _PWIDW { w: self } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&mut self) -> _PTYPW { + _PTYPW { w: self } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&mut self) -> _PBKENW { + _PBKENW { w: self } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&mut self) -> _PWAITENW { + _PWAITENW { w: self } + } +} diff --git a/src/fsmc/pcr4/mod.rs b/src/fsmc/pcr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..119740ab0480aa59b2f0b0752122bc9386b75fdf --- /dev/null +++ b/src/fsmc/pcr4/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ECCPSR { + bits: u8, +} +impl ECCPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TARR { + bits: u8, +} +impl TARR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TCLRR { + bits: u8, +} +impl TCLRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ECCENR { + bits: bool, +} +impl ECCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWIDR { + bits: u8, +} +impl PWIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTYPR { + bits: bool, +} +impl PTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PBKENR { + bits: bool, +} +impl PBKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWAITENR { + bits: bool, +} +impl PWAITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ECCPSW<'a> { + w: &'a mut W, +} +impl<'a> _ECCPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TARW<'a> { + w: &'a mut W, +} +impl<'a> _TARW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCLRW<'a> { + w: &'a mut W, +} +impl<'a> _TCLRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECCENW<'a> { + w: &'a mut W, +} +impl<'a> _ECCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWIDW<'a> { + w: &'a mut W, +} +impl<'a> _PWIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTYPW<'a> { + w: &'a mut W, +} +impl<'a> _PTYPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PBKENW<'a> { + w: &'a mut W, +} +impl<'a> _PBKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWAITENW<'a> { + w: &'a mut W, +} +impl<'a> _PWAITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&self) -> ECCPSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ECCPSR { bits } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&self) -> TARR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TARR { bits } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&self) -> TCLRR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TCLRR { bits } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&self) -> ECCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECCENR { bits } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&self) -> PWIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PWIDR { bits } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&self) -> PTYPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTYPR { bits } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&self) -> PBKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PBKENR { bits } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&self) -> PWAITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWAITENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 24 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 17:19 - ECCPS"] + #[inline] + pub fn eccps(&mut self) -> _ECCPSW { + _ECCPSW { w: self } + } + #[doc = "Bits 13:16 - TAR"] + #[inline] + pub fn tar(&mut self) -> _TARW { + _TARW { w: self } + } + #[doc = "Bits 9:12 - TCLR"] + #[inline] + pub fn tclr(&mut self) -> _TCLRW { + _TCLRW { w: self } + } + #[doc = "Bit 6 - ECCEN"] + #[inline] + pub fn eccen(&mut self) -> _ECCENW { + _ECCENW { w: self } + } + #[doc = "Bits 4:5 - PWID"] + #[inline] + pub fn pwid(&mut self) -> _PWIDW { + _PWIDW { w: self } + } + #[doc = "Bit 3 - PTYP"] + #[inline] + pub fn ptyp(&mut self) -> _PTYPW { + _PTYPW { w: self } + } + #[doc = "Bit 2 - PBKEN"] + #[inline] + pub fn pbken(&mut self) -> _PBKENW { + _PBKENW { w: self } + } + #[doc = "Bit 1 - PWAITEN"] + #[inline] + pub fn pwaiten(&mut self) -> _PWAITENW { + _PWAITENW { w: self } + } +} diff --git a/src/fsmc/pio4/mod.rs b/src/fsmc/pio4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..16383549b6b253d23143e86810b56b63ae07e07d --- /dev/null +++ b/src/fsmc/pio4/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PIO4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IOHIZXR { + bits: u8, +} +impl IOHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOHOLDXR { + bits: u8, +} +impl IOHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOWAITXR { + bits: u8, +} +impl IOWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IOSETXR { + bits: u8, +} +impl IOSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IOHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _IOHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _IOHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _IOWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IOSETXW<'a> { + w: &'a mut W, +} +impl<'a> _IOSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - IOHIZx"] + #[inline] + pub fn iohizx(&self) -> IOHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOHIZXR { bits } + } + #[doc = "Bits 16:23 - IOHOLDx"] + #[inline] + pub fn ioholdx(&self) -> IOHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOHOLDXR { bits } + } + #[doc = "Bits 8:15 - IOWAITx"] + #[inline] + pub fn iowaitx(&self) -> IOWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOWAITXR { bits } + } + #[doc = "Bits 0:7 - IOSETx"] + #[inline] + pub fn iosetx(&self) -> IOSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IOSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - IOHIZx"] + #[inline] + pub fn iohizx(&mut self) -> _IOHIZXW { + _IOHIZXW { w: self } + } + #[doc = "Bits 16:23 - IOHOLDx"] + #[inline] + pub fn ioholdx(&mut self) -> _IOHOLDXW { + _IOHOLDXW { w: self } + } + #[doc = "Bits 8:15 - IOWAITx"] + #[inline] + pub fn iowaitx(&mut self) -> _IOWAITXW { + _IOWAITXW { w: self } + } + #[doc = "Bits 0:7 - IOSETx"] + #[inline] + pub fn iosetx(&mut self) -> _IOSETXW { + _IOSETXW { w: self } + } +} diff --git a/src/fsmc/pmem2/mod.rs b/src/fsmc/pmem2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b8996bc09fea397082a555ab8fb28550cfd94548 --- /dev/null +++ b/src/fsmc/pmem2/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PMEM2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MEMHIZXR { + bits: u8, +} +impl MEMHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMHOLDXR { + bits: u8, +} +impl MEMHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMWAITXR { + bits: u8, +} +impl MEMWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMSETXR { + bits: u8, +} +impl MEMSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MEMHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMSETXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&self) -> MEMHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHIZXR { bits } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&self) -> MEMHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHOLDXR { bits } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&self) -> MEMWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMWAITXR { bits } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&self) -> MEMSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&mut self) -> _MEMHIZXW { + _MEMHIZXW { w: self } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&mut self) -> _MEMHOLDXW { + _MEMHOLDXW { w: self } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&mut self) -> _MEMWAITXW { + _MEMWAITXW { w: self } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&mut self) -> _MEMSETXW { + _MEMSETXW { w: self } + } +} diff --git a/src/fsmc/pmem3/mod.rs b/src/fsmc/pmem3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7fdf8f118b72bb40fe52faa63e023ff197931e06 --- /dev/null +++ b/src/fsmc/pmem3/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PMEM3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MEMHIZXR { + bits: u8, +} +impl MEMHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMHOLDXR { + bits: u8, +} +impl MEMHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMWAITXR { + bits: u8, +} +impl MEMWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMSETXR { + bits: u8, +} +impl MEMSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MEMHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMSETXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&self) -> MEMHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHIZXR { bits } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&self) -> MEMHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHOLDXR { bits } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&self) -> MEMWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMWAITXR { bits } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&self) -> MEMSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&mut self) -> _MEMHIZXW { + _MEMHIZXW { w: self } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&mut self) -> _MEMHOLDXW { + _MEMHOLDXW { w: self } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&mut self) -> _MEMWAITXW { + _MEMWAITXW { w: self } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&mut self) -> _MEMSETXW { + _MEMSETXW { w: self } + } +} diff --git a/src/fsmc/pmem4/mod.rs b/src/fsmc/pmem4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..43c6f17614e7ec9a72ad5d2a0b8915538c27bbd1 --- /dev/null +++ b/src/fsmc/pmem4/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PMEM4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MEMHIZXR { + bits: u8, +} +impl MEMHIZXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMHOLDXR { + bits: u8, +} +impl MEMHOLDXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMWAITXR { + bits: u8, +} +impl MEMWAITXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MEMSETXR { + bits: u8, +} +impl MEMSETXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MEMHIZXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHIZXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMHOLDXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMHOLDXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMWAITXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMWAITXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MEMSETXW<'a> { + w: &'a mut W, +} +impl<'a> _MEMSETXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&self) -> MEMHIZXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHIZXR { bits } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&self) -> MEMHOLDXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMHOLDXR { bits } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&self) -> MEMWAITXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMWAITXR { bits } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&self) -> MEMSETXR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEMSETXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4244438268 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - MEMHIZx"] + #[inline] + pub fn memhizx(&mut self) -> _MEMHIZXW { + _MEMHIZXW { w: self } + } + #[doc = "Bits 16:23 - MEMHOLDx"] + #[inline] + pub fn memholdx(&mut self) -> _MEMHOLDXW { + _MEMHOLDXW { w: self } + } + #[doc = "Bits 8:15 - MEMWAITx"] + #[inline] + pub fn memwaitx(&mut self) -> _MEMWAITXW { + _MEMWAITXW { w: self } + } + #[doc = "Bits 0:7 - MEMSETx"] + #[inline] + pub fn memsetx(&mut self) -> _MEMSETXW { + _MEMSETXW { w: self } + } +} diff --git a/src/fsmc/sr2/mod.rs b/src/fsmc/sr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..89c9d09ad1604e75d020c3d24379422988c03f1a --- /dev/null +++ b/src/fsmc/sr2/mod.rs @@ -0,0 +1,449 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEMPTR { + bits: bool, +} +impl FEMPTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFENR { + bits: bool, +} +impl IFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILENR { + bits: bool, +} +impl ILENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRENR { + bits: bool, +} +impl IRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFSR { + bits: bool, +} +impl IFSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILSR { + bits: bool, +} +impl ILSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRSR { + bits: bool, +} +impl IRSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _IFENW<'a> { + w: &'a mut W, +} +impl<'a> _IFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILENW<'a> { + w: &'a mut W, +} +impl<'a> _ILENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRENW<'a> { + w: &'a mut W, +} +impl<'a> _IRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IFSW<'a> { + w: &'a mut W, +} +impl<'a> _IFSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILSW<'a> { + w: &'a mut W, +} +impl<'a> _ILSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRSW<'a> { + w: &'a mut W, +} +impl<'a> _IRSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - FEMPT"] + #[inline] + pub fn fempt(&self) -> FEMPTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEMPTR { bits } + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&self) -> IFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFENR { bits } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&self) -> ILENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILENR { bits } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&self) -> IRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRENR { bits } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&self) -> IFSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFSR { bits } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&self) -> ILSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILSR { bits } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&self) -> IRSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 64 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&mut self) -> _IFENW { + _IFENW { w: self } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&mut self) -> _ILENW { + _ILENW { w: self } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&mut self) -> _IRENW { + _IRENW { w: self } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&mut self) -> _IFSW { + _IFSW { w: self } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&mut self) -> _ILSW { + _ILSW { w: self } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&mut self) -> _IRSW { + _IRSW { w: self } + } +} diff --git a/src/fsmc/sr3/mod.rs b/src/fsmc/sr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3620cd3f532c8d36679c5a4360eb886211ec8ee5 --- /dev/null +++ b/src/fsmc/sr3/mod.rs @@ -0,0 +1,449 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEMPTR { + bits: bool, +} +impl FEMPTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFENR { + bits: bool, +} +impl IFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILENR { + bits: bool, +} +impl ILENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRENR { + bits: bool, +} +impl IRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFSR { + bits: bool, +} +impl IFSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILSR { + bits: bool, +} +impl ILSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRSR { + bits: bool, +} +impl IRSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _IFENW<'a> { + w: &'a mut W, +} +impl<'a> _IFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILENW<'a> { + w: &'a mut W, +} +impl<'a> _ILENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRENW<'a> { + w: &'a mut W, +} +impl<'a> _IRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IFSW<'a> { + w: &'a mut W, +} +impl<'a> _IFSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILSW<'a> { + w: &'a mut W, +} +impl<'a> _ILSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRSW<'a> { + w: &'a mut W, +} +impl<'a> _IRSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - FEMPT"] + #[inline] + pub fn fempt(&self) -> FEMPTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEMPTR { bits } + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&self) -> IFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFENR { bits } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&self) -> ILENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILENR { bits } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&self) -> IRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRENR { bits } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&self) -> IFSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFSR { bits } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&self) -> ILSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILSR { bits } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&self) -> IRSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 64 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&mut self) -> _IFENW { + _IFENW { w: self } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&mut self) -> _ILENW { + _ILENW { w: self } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&mut self) -> _IRENW { + _IRENW { w: self } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&mut self) -> _IFSW { + _IFSW { w: self } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&mut self) -> _ILSW { + _ILSW { w: self } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&mut self) -> _IRSW { + _IRSW { w: self } + } +} diff --git a/src/fsmc/sr4/mod.rs b/src/fsmc/sr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..940fe40697f542ec811f3228fa4f62375fba67e9 --- /dev/null +++ b/src/fsmc/sr4/mod.rs @@ -0,0 +1,449 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FEMPTR { + bits: bool, +} +impl FEMPTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFENR { + bits: bool, +} +impl IFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILENR { + bits: bool, +} +impl ILENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRENR { + bits: bool, +} +impl IRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IFSR { + bits: bool, +} +impl IFSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ILSR { + bits: bool, +} +impl ILSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRSR { + bits: bool, +} +impl IRSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _IFENW<'a> { + w: &'a mut W, +} +impl<'a> _IFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILENW<'a> { + w: &'a mut W, +} +impl<'a> _ILENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRENW<'a> { + w: &'a mut W, +} +impl<'a> _IRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IFSW<'a> { + w: &'a mut W, +} +impl<'a> _IFSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ILSW<'a> { + w: &'a mut W, +} +impl<'a> _ILSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRSW<'a> { + w: &'a mut W, +} +impl<'a> _IRSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - FEMPT"] + #[inline] + pub fn fempt(&self) -> FEMPTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FEMPTR { bits } + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&self) -> IFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFENR { bits } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&self) -> ILENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILENR { bits } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&self) -> IRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRENR { bits } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&self) -> IFSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IFSR { bits } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&self) -> ILSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ILSR { bits } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&self) -> IRSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 64 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 5 - IFEN"] + #[inline] + pub fn ifen(&mut self) -> _IFENW { + _IFENW { w: self } + } + #[doc = "Bit 4 - ILEN"] + #[inline] + pub fn ilen(&mut self) -> _ILENW { + _ILENW { w: self } + } + #[doc = "Bit 3 - IREN"] + #[inline] + pub fn iren(&mut self) -> _IRENW { + _IRENW { w: self } + } + #[doc = "Bit 2 - IFS"] + #[inline] + pub fn ifs(&mut self) -> _IFSW { + _IFSW { w: self } + } + #[doc = "Bit 1 - ILS"] + #[inline] + pub fn ils(&mut self) -> _ILSW { + _ILSW { w: self } + } + #[doc = "Bit 0 - IRS"] + #[inline] + pub fn irs(&mut self) -> _IRSW { + _IRSW { w: self } + } +} diff --git a/src/gpioa/afrh/mod.rs b/src/gpioa/afrh/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2fa3c156601a21f55db69941b999372cb7c44fa3 --- /dev/null +++ b/src/gpioa/afrh/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRH { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRH15R { + bits: u8, +} +impl AFRH15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH14R { + bits: u8, +} +impl AFRH14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH13R { + bits: u8, +} +impl AFRH13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH12R { + bits: u8, +} +impl AFRH12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH11R { + bits: u8, +} +impl AFRH11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH10R { + bits: u8, +} +impl AFRH10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH9R { + bits: u8, +} +impl AFRH9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH8R { + bits: u8, +} +impl AFRH8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRH15W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH14W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH13W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH12W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH11W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH10W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH9W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH8W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&self) -> AFRH15R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH15R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&self) -> AFRH14R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH14R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&self) -> AFRH13R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH13R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&self) -> AFRH12R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH12R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&self) -> AFRH11R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH11R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&self) -> AFRH10R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH10R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&self) -> AFRH9R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH9R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&self) -> AFRH8R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH8R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&mut self) -> _AFRH15W { + _AFRH15W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&mut self) -> _AFRH14W { + _AFRH14W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&mut self) -> _AFRH13W { + _AFRH13W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&mut self) -> _AFRH12W { + _AFRH12W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&mut self) -> _AFRH11W { + _AFRH11W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&mut self) -> _AFRH10W { + _AFRH10W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&mut self) -> _AFRH9W { + _AFRH9W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&mut self) -> _AFRH8W { + _AFRH8W { w: self } + } +} diff --git a/src/gpioa/afrl/mod.rs b/src/gpioa/afrl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..630035c446d0c8a1259a7deff7a014fe582b903c --- /dev/null +++ b/src/gpioa/afrl/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRL7R { + bits: u8, +} +impl AFRL7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL6R { + bits: u8, +} +impl AFRL6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL5R { + bits: u8, +} +impl AFRL5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL4R { + bits: u8, +} +impl AFRL4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL3R { + bits: u8, +} +impl AFRL3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL2R { + bits: u8, +} +impl AFRL2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL1R { + bits: u8, +} +impl AFRL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL0R { + bits: u8, +} +impl AFRL0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRL7W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL6W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL5W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL4W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL3W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL2W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL1W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL0W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&self) -> AFRL7R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL7R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&self) -> AFRL6R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL6R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&self) -> AFRL5R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL5R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&self) -> AFRL4R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL4R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&self) -> AFRL3R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL3R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&self) -> AFRL2R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL2R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&self) -> AFRL1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL1R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&self) -> AFRL0R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&mut self) -> _AFRL7W { + _AFRL7W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&mut self) -> _AFRL6W { + _AFRL6W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&mut self) -> _AFRL5W { + _AFRL5W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&mut self) -> _AFRL4W { + _AFRL4W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&mut self) -> _AFRL3W { + _AFRL3W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&mut self) -> _AFRL2W { + _AFRL2W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&mut self) -> _AFRL1W { + _AFRL1W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&mut self) -> _AFRL0W { + _AFRL0W { w: self } + } +} diff --git a/src/gpioa/bsrr/mod.rs b/src/gpioa/bsrr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..246617bfc79601abd4543412ff6a478ee2fb7755 --- /dev/null +++ b/src/gpioa/bsrr/mod.rs @@ -0,0 +1,925 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BSRR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _BR15W<'a> { + w: &'a mut W, +} +impl<'a> _BR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR14W<'a> { + w: &'a mut W, +} +impl<'a> _BR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR13W<'a> { + w: &'a mut W, +} +impl<'a> _BR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR12W<'a> { + w: &'a mut W, +} +impl<'a> _BR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR11W<'a> { + w: &'a mut W, +} +impl<'a> _BR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR10W<'a> { + w: &'a mut W, +} +impl<'a> _BR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR9W<'a> { + w: &'a mut W, +} +impl<'a> _BR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR8W<'a> { + w: &'a mut W, +} +impl<'a> _BR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR7W<'a> { + w: &'a mut W, +} +impl<'a> _BR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR6W<'a> { + w: &'a mut W, +} +impl<'a> _BR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR5W<'a> { + w: &'a mut W, +} +impl<'a> _BR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR4W<'a> { + w: &'a mut W, +} +impl<'a> _BR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR3W<'a> { + w: &'a mut W, +} +impl<'a> _BR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR2W<'a> { + w: &'a mut W, +} +impl<'a> _BR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR1W<'a> { + w: &'a mut W, +} +impl<'a> _BR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR0W<'a> { + w: &'a mut W, +} +impl<'a> _BR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS15W<'a> { + w: &'a mut W, +} +impl<'a> _BS15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS14W<'a> { + w: &'a mut W, +} +impl<'a> _BS14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS13W<'a> { + w: &'a mut W, +} +impl<'a> _BS13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS12W<'a> { + w: &'a mut W, +} +impl<'a> _BS12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS11W<'a> { + w: &'a mut W, +} +impl<'a> _BS11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS10W<'a> { + w: &'a mut W, +} +impl<'a> _BS10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS9W<'a> { + w: &'a mut W, +} +impl<'a> _BS9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS8W<'a> { + w: &'a mut W, +} +impl<'a> _BS8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS7W<'a> { + w: &'a mut W, +} +impl<'a> _BS7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS6W<'a> { + w: &'a mut W, +} +impl<'a> _BS6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS5W<'a> { + w: &'a mut W, +} +impl<'a> _BS5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS4W<'a> { + w: &'a mut W, +} +impl<'a> _BS4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS3W<'a> { + w: &'a mut W, +} +impl<'a> _BS3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS2W<'a> { + w: &'a mut W, +} +impl<'a> _BS2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS1W<'a> { + w: &'a mut W, +} +impl<'a> _BS1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS0W<'a> { + w: &'a mut W, +} +impl<'a> _BS0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br15(&mut self) -> _BR15W { + _BR15W { w: self } + } + #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br14(&mut self) -> _BR14W { + _BR14W { w: self } + } + #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br13(&mut self) -> _BR13W { + _BR13W { w: self } + } + #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br12(&mut self) -> _BR12W { + _BR12W { w: self } + } + #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br11(&mut self) -> _BR11W { + _BR11W { w: self } + } + #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br10(&mut self) -> _BR10W { + _BR10W { w: self } + } + #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br9(&mut self) -> _BR9W { + _BR9W { w: self } + } + #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br8(&mut self) -> _BR8W { + _BR8W { w: self } + } + #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br7(&mut self) -> _BR7W { + _BR7W { w: self } + } + #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br6(&mut self) -> _BR6W { + _BR6W { w: self } + } + #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br5(&mut self) -> _BR5W { + _BR5W { w: self } + } + #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br4(&mut self) -> _BR4W { + _BR4W { w: self } + } + #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br3(&mut self) -> _BR3W { + _BR3W { w: self } + } + #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br2(&mut self) -> _BR2W { + _BR2W { w: self } + } + #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br1(&mut self) -> _BR1W { + _BR1W { w: self } + } + #[doc = "Bit 16 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn br0(&mut self) -> _BR0W { + _BR0W { w: self } + } + #[doc = "Bit 15 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs15(&mut self) -> _BS15W { + _BS15W { w: self } + } + #[doc = "Bit 14 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs14(&mut self) -> _BS14W { + _BS14W { w: self } + } + #[doc = "Bit 13 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs13(&mut self) -> _BS13W { + _BS13W { w: self } + } + #[doc = "Bit 12 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs12(&mut self) -> _BS12W { + _BS12W { w: self } + } + #[doc = "Bit 11 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs11(&mut self) -> _BS11W { + _BS11W { w: self } + } + #[doc = "Bit 10 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs10(&mut self) -> _BS10W { + _BS10W { w: self } + } + #[doc = "Bit 9 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs9(&mut self) -> _BS9W { + _BS9W { w: self } + } + #[doc = "Bit 8 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs8(&mut self) -> _BS8W { + _BS8W { w: self } + } + #[doc = "Bit 7 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs7(&mut self) -> _BS7W { + _BS7W { w: self } + } + #[doc = "Bit 6 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs6(&mut self) -> _BS6W { + _BS6W { w: self } + } + #[doc = "Bit 5 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs5(&mut self) -> _BS5W { + _BS5W { w: self } + } + #[doc = "Bit 4 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs4(&mut self) -> _BS4W { + _BS4W { w: self } + } + #[doc = "Bit 3 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs3(&mut self) -> _BS3W { + _BS3W { w: self } + } + #[doc = "Bit 2 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs2(&mut self) -> _BS2W { + _BS2W { w: self } + } + #[doc = "Bit 1 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs1(&mut self) -> _BS1W { + _BS1W { w: self } + } + #[doc = "Bit 0 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs0(&mut self) -> _BS0W { + _BS0W { w: self } + } +} diff --git a/src/gpioa/idr/mod.rs b/src/gpioa/idr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab2006bf57931967f67d50aff2687cf8574c203b --- /dev/null +++ b/src/gpioa/idr/mod.rs @@ -0,0 +1,516 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::IDR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct IDR15R { + bits: bool, +} +impl IDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR14R { + bits: bool, +} +impl IDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR13R { + bits: bool, +} +impl IDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR12R { + bits: bool, +} +impl IDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR11R { + bits: bool, +} +impl IDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR10R { + bits: bool, +} +impl IDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR9R { + bits: bool, +} +impl IDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR8R { + bits: bool, +} +impl IDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR7R { + bits: bool, +} +impl IDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR6R { + bits: bool, +} +impl IDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR5R { + bits: bool, +} +impl IDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR4R { + bits: bool, +} +impl IDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR3R { + bits: bool, +} +impl IDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR2R { + bits: bool, +} +impl IDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR1R { + bits: bool, +} +impl IDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR0R { + bits: bool, +} +impl IDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port input data (y = 0..15)"] + #[inline] + pub fn idr15(&self) -> IDR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR15R { bits } + } + #[doc = "Bit 14 - Port input data (y = 0..15)"] + #[inline] + pub fn idr14(&self) -> IDR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR14R { bits } + } + #[doc = "Bit 13 - Port input data (y = 0..15)"] + #[inline] + pub fn idr13(&self) -> IDR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR13R { bits } + } + #[doc = "Bit 12 - Port input data (y = 0..15)"] + #[inline] + pub fn idr12(&self) -> IDR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR12R { bits } + } + #[doc = "Bit 11 - Port input data (y = 0..15)"] + #[inline] + pub fn idr11(&self) -> IDR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR11R { bits } + } + #[doc = "Bit 10 - Port input data (y = 0..15)"] + #[inline] + pub fn idr10(&self) -> IDR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR10R { bits } + } + #[doc = "Bit 9 - Port input data (y = 0..15)"] + #[inline] + pub fn idr9(&self) -> IDR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR9R { bits } + } + #[doc = "Bit 8 - Port input data (y = 0..15)"] + #[inline] + pub fn idr8(&self) -> IDR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR8R { bits } + } + #[doc = "Bit 7 - Port input data (y = 0..15)"] + #[inline] + pub fn idr7(&self) -> IDR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR7R { bits } + } + #[doc = "Bit 6 - Port input data (y = 0..15)"] + #[inline] + pub fn idr6(&self) -> IDR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR6R { bits } + } + #[doc = "Bit 5 - Port input data (y = 0..15)"] + #[inline] + pub fn idr5(&self) -> IDR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR5R { bits } + } + #[doc = "Bit 4 - Port input data (y = 0..15)"] + #[inline] + pub fn idr4(&self) -> IDR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR4R { bits } + } + #[doc = "Bit 3 - Port input data (y = 0..15)"] + #[inline] + pub fn idr3(&self) -> IDR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR3R { bits } + } + #[doc = "Bit 2 - Port input data (y = 0..15)"] + #[inline] + pub fn idr2(&self) -> IDR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR2R { bits } + } + #[doc = "Bit 1 - Port input data (y = 0..15)"] + #[inline] + pub fn idr1(&self) -> IDR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR1R { bits } + } + #[doc = "Bit 0 - Port input data (y = 0..15)"] + #[inline] + pub fn idr0(&self) -> IDR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR0R { bits } + } +} diff --git a/src/gpioa/lckr/mod.rs b/src/gpioa/lckr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..76660a645cbfb96d5e6cf456fcff0f87a3fa2dbb --- /dev/null +++ b/src/gpioa/lckr/mod.rs @@ -0,0 +1,1067 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LCKR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LCKKR { + bits: bool, +} +impl LCKKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK15R { + bits: bool, +} +impl LCK15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK14R { + bits: bool, +} +impl LCK14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK13R { + bits: bool, +} +impl LCK13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK12R { + bits: bool, +} +impl LCK12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK11R { + bits: bool, +} +impl LCK11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK10R { + bits: bool, +} +impl LCK10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK9R { + bits: bool, +} +impl LCK9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK8R { + bits: bool, +} +impl LCK8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK7R { + bits: bool, +} +impl LCK7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK6R { + bits: bool, +} +impl LCK6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK5R { + bits: bool, +} +impl LCK5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK4R { + bits: bool, +} +impl LCK4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK3R { + bits: bool, +} +impl LCK3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK2R { + bits: bool, +} +impl LCK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK1R { + bits: bool, +} +impl LCK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK0R { + bits: bool, +} +impl LCK0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LCKKW<'a> { + w: &'a mut W, +} +impl<'a> _LCKKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK15W<'a> { + w: &'a mut W, +} +impl<'a> _LCK15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK14W<'a> { + w: &'a mut W, +} +impl<'a> _LCK14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK13W<'a> { + w: &'a mut W, +} +impl<'a> _LCK13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK12W<'a> { + w: &'a mut W, +} +impl<'a> _LCK12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK11W<'a> { + w: &'a mut W, +} +impl<'a> _LCK11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK10W<'a> { + w: &'a mut W, +} +impl<'a> _LCK10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK9W<'a> { + w: &'a mut W, +} +impl<'a> _LCK9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK8W<'a> { + w: &'a mut W, +} +impl<'a> _LCK8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK7W<'a> { + w: &'a mut W, +} +impl<'a> _LCK7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK6W<'a> { + w: &'a mut W, +} +impl<'a> _LCK6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK5W<'a> { + w: &'a mut W, +} +impl<'a> _LCK5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK4W<'a> { + w: &'a mut W, +} +impl<'a> _LCK4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK3W<'a> { + w: &'a mut W, +} +impl<'a> _LCK3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK2W<'a> { + w: &'a mut W, +} +impl<'a> _LCK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK1W<'a> { + w: &'a mut W, +} +impl<'a> _LCK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK0W<'a> { + w: &'a mut W, +} +impl<'a> _LCK0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&self) -> LCKKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCKKR { bits } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&self) -> LCK15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK15R { bits } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&self) -> LCK14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK14R { bits } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&self) -> LCK13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK13R { bits } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&self) -> LCK12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK12R { bits } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&self) -> LCK11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK11R { bits } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&self) -> LCK10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK10R { bits } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&self) -> LCK9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK9R { bits } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&self) -> LCK8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK8R { bits } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&self) -> LCK7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK7R { bits } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&self) -> LCK6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK6R { bits } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&self) -> LCK5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK5R { bits } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&self) -> LCK4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK4R { bits } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&self) -> LCK3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK3R { bits } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&self) -> LCK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK2R { bits } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&self) -> LCK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK1R { bits } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&self) -> LCK0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&mut self) -> _LCKKW { + _LCKKW { w: self } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&mut self) -> _LCK15W { + _LCK15W { w: self } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&mut self) -> _LCK14W { + _LCK14W { w: self } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&mut self) -> _LCK13W { + _LCK13W { w: self } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&mut self) -> _LCK12W { + _LCK12W { w: self } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&mut self) -> _LCK11W { + _LCK11W { w: self } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&mut self) -> _LCK10W { + _LCK10W { w: self } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&mut self) -> _LCK9W { + _LCK9W { w: self } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&mut self) -> _LCK8W { + _LCK8W { w: self } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&mut self) -> _LCK7W { + _LCK7W { w: self } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&mut self) -> _LCK6W { + _LCK6W { w: self } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&mut self) -> _LCK5W { + _LCK5W { w: self } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&mut self) -> _LCK4W { + _LCK4W { w: self } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&mut self) -> _LCK3W { + _LCK3W { w: self } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&mut self) -> _LCK2W { + _LCK2W { w: self } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&mut self) -> _LCK1W { + _LCK1W { w: self } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&mut self) -> _LCK0W { + _LCK0W { w: self } + } +} diff --git a/src/gpioa/mod.rs b/src/gpioa/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..048d6055d4f9cc1f13ef6b534676451c28c9a7ba --- /dev/null +++ b/src/gpioa/mod.rs @@ -0,0 +1,84 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - GPIO port mode register"] + pub moder: MODER, + #[doc = "0x04 - GPIO port output type register"] + pub otyper: OTYPER, + #[doc = "0x08 - GPIO port output speed register"] + pub ospeedr: OSPEEDR, + #[doc = "0x0c - GPIO port pull-up/pull-down register"] + pub pupdr: PUPDR, + #[doc = "0x10 - GPIO port input data register"] + pub idr: IDR, + #[doc = "0x14 - GPIO port output data register"] + pub odr: ODR, + #[doc = "0x18 - GPIO port bit set/reset register"] + pub bsrr: BSRR, + #[doc = "0x1c - GPIO port configuration lock register"] + pub lckr: LCKR, + #[doc = "0x20 - GPIO alternate function low register"] + pub afrl: AFRL, + #[doc = "0x24 - GPIO alternate function high register"] + pub afrh: AFRH, +} +#[doc = "GPIO port mode register"] +pub struct MODER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port mode register"] +pub mod moder; +#[doc = "GPIO port output type register"] +pub struct OTYPER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output type register"] +pub mod otyper; +#[doc = "GPIO port output speed register"] +pub struct OSPEEDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output speed register"] +pub mod ospeedr; +#[doc = "GPIO port pull-up/pull-down register"] +pub struct PUPDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port pull-up/pull-down register"] +pub mod pupdr; +#[doc = "GPIO port input data register"] +pub struct IDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port input data register"] +pub mod idr; +#[doc = "GPIO port output data register"] +pub struct ODR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output data register"] +pub mod odr; +#[doc = "GPIO port bit set/reset register"] +pub struct BSRR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port bit set/reset register"] +pub mod bsrr; +#[doc = "GPIO port configuration lock register"] +pub struct LCKR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port configuration lock register"] +pub mod lckr; +#[doc = "GPIO alternate function low register"] +pub struct AFRL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function low register"] +pub mod afrl; +#[doc = "GPIO alternate function high register"] +pub struct AFRH { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function high register"] +pub mod afrh; diff --git a/src/gpioa/moder/mod.rs b/src/gpioa/moder/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..62e56a2e25562b838ce67ec7b1ffafee6a095db0 --- /dev/null +++ b/src/gpioa/moder/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MODER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MODER15R { + bits: u8, +} +impl MODER15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER14R { + bits: u8, +} +impl MODER14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER13R { + bits: u8, +} +impl MODER13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER12R { + bits: u8, +} +impl MODER12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER11R { + bits: u8, +} +impl MODER11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER10R { + bits: u8, +} +impl MODER10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER9R { + bits: u8, +} +impl MODER9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER8R { + bits: u8, +} +impl MODER8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER7R { + bits: u8, +} +impl MODER7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER6R { + bits: u8, +} +impl MODER6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER5R { + bits: u8, +} +impl MODER5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER4R { + bits: u8, +} +impl MODER4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER3R { + bits: u8, +} +impl MODER3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER2R { + bits: u8, +} +impl MODER2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER1R { + bits: u8, +} +impl MODER1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER0R { + bits: u8, +} +impl MODER0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MODER15W<'a> { + w: &'a mut W, +} +impl<'a> _MODER15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER14W<'a> { + w: &'a mut W, +} +impl<'a> _MODER14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER13W<'a> { + w: &'a mut W, +} +impl<'a> _MODER13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER12W<'a> { + w: &'a mut W, +} +impl<'a> _MODER12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER11W<'a> { + w: &'a mut W, +} +impl<'a> _MODER11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER10W<'a> { + w: &'a mut W, +} +impl<'a> _MODER10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER9W<'a> { + w: &'a mut W, +} +impl<'a> _MODER9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER8W<'a> { + w: &'a mut W, +} +impl<'a> _MODER8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER7W<'a> { + w: &'a mut W, +} +impl<'a> _MODER7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER6W<'a> { + w: &'a mut W, +} +impl<'a> _MODER6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER5W<'a> { + w: &'a mut W, +} +impl<'a> _MODER5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER4W<'a> { + w: &'a mut W, +} +impl<'a> _MODER4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER3W<'a> { + w: &'a mut W, +} +impl<'a> _MODER3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER2W<'a> { + w: &'a mut W, +} +impl<'a> _MODER2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER1W<'a> { + w: &'a mut W, +} +impl<'a> _MODER1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER0W<'a> { + w: &'a mut W, +} +impl<'a> _MODER0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&self) -> MODER15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&self) -> MODER14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&self) -> MODER13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&self) -> MODER12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&self) -> MODER11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&self) -> MODER10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&self) -> MODER9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&self) -> MODER8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&self) -> MODER7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&self) -> MODER6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&self) -> MODER5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&self) -> MODER4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&self) -> MODER3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&self) -> MODER2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&self) -> MODER1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&self) -> MODER0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2818572288 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&mut self) -> _MODER15W { + _MODER15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&mut self) -> _MODER14W { + _MODER14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&mut self) -> _MODER13W { + _MODER13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&mut self) -> _MODER12W { + _MODER12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&mut self) -> _MODER11W { + _MODER11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&mut self) -> _MODER10W { + _MODER10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&mut self) -> _MODER9W { + _MODER9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&mut self) -> _MODER8W { + _MODER8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&mut self) -> _MODER7W { + _MODER7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&mut self) -> _MODER6W { + _MODER6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&mut self) -> _MODER5W { + _MODER5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&mut self) -> _MODER4W { + _MODER4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&mut self) -> _MODER3W { + _MODER3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&mut self) -> _MODER2W { + _MODER2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&mut self) -> _MODER1W { + _MODER1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&mut self) -> _MODER0W { + _MODER0W { w: self } + } +} diff --git a/src/gpioa/odr/mod.rs b/src/gpioa/odr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e06ac5caf011b0351b245bea4964cda77f34de78 --- /dev/null +++ b/src/gpioa/odr/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ODR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ODR15R { + bits: bool, +} +impl ODR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR14R { + bits: bool, +} +impl ODR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR13R { + bits: bool, +} +impl ODR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR12R { + bits: bool, +} +impl ODR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR11R { + bits: bool, +} +impl ODR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR10R { + bits: bool, +} +impl ODR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR9R { + bits: bool, +} +impl ODR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR8R { + bits: bool, +} +impl ODR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR7R { + bits: bool, +} +impl ODR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR6R { + bits: bool, +} +impl ODR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR5R { + bits: bool, +} +impl ODR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR4R { + bits: bool, +} +impl ODR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR3R { + bits: bool, +} +impl ODR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR2R { + bits: bool, +} +impl ODR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR1R { + bits: bool, +} +impl ODR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR0R { + bits: bool, +} +impl ODR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ODR15W<'a> { + w: &'a mut W, +} +impl<'a> _ODR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR14W<'a> { + w: &'a mut W, +} +impl<'a> _ODR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR13W<'a> { + w: &'a mut W, +} +impl<'a> _ODR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR12W<'a> { + w: &'a mut W, +} +impl<'a> _ODR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR11W<'a> { + w: &'a mut W, +} +impl<'a> _ODR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR10W<'a> { + w: &'a mut W, +} +impl<'a> _ODR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR9W<'a> { + w: &'a mut W, +} +impl<'a> _ODR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR8W<'a> { + w: &'a mut W, +} +impl<'a> _ODR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR7W<'a> { + w: &'a mut W, +} +impl<'a> _ODR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR6W<'a> { + w: &'a mut W, +} +impl<'a> _ODR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR5W<'a> { + w: &'a mut W, +} +impl<'a> _ODR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR4W<'a> { + w: &'a mut W, +} +impl<'a> _ODR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR3W<'a> { + w: &'a mut W, +} +impl<'a> _ODR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR2W<'a> { + w: &'a mut W, +} +impl<'a> _ODR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR1W<'a> { + w: &'a mut W, +} +impl<'a> _ODR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR0W<'a> { + w: &'a mut W, +} +impl<'a> _ODR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&self) -> ODR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR15R { bits } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&self) -> ODR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR14R { bits } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&self) -> ODR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR13R { bits } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&self) -> ODR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR12R { bits } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&self) -> ODR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR11R { bits } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&self) -> ODR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR10R { bits } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&self) -> ODR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR9R { bits } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&self) -> ODR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR8R { bits } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&self) -> ODR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR7R { bits } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&self) -> ODR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR6R { bits } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&self) -> ODR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR5R { bits } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&self) -> ODR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR4R { bits } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&self) -> ODR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR3R { bits } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&self) -> ODR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR2R { bits } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&self) -> ODR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR1R { bits } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&self) -> ODR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&mut self) -> _ODR15W { + _ODR15W { w: self } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&mut self) -> _ODR14W { + _ODR14W { w: self } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&mut self) -> _ODR13W { + _ODR13W { w: self } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&mut self) -> _ODR12W { + _ODR12W { w: self } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&mut self) -> _ODR11W { + _ODR11W { w: self } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&mut self) -> _ODR10W { + _ODR10W { w: self } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&mut self) -> _ODR9W { + _ODR9W { w: self } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&mut self) -> _ODR8W { + _ODR8W { w: self } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&mut self) -> _ODR7W { + _ODR7W { w: self } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&mut self) -> _ODR6W { + _ODR6W { w: self } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&mut self) -> _ODR5W { + _ODR5W { w: self } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&mut self) -> _ODR4W { + _ODR4W { w: self } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&mut self) -> _ODR3W { + _ODR3W { w: self } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&mut self) -> _ODR2W { + _ODR2W { w: self } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&mut self) -> _ODR1W { + _ODR1W { w: self } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&mut self) -> _ODR0W { + _ODR0W { w: self } + } +} diff --git a/src/gpioa/ospeedr/mod.rs b/src/gpioa/ospeedr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6502d202dd0308244f74bb245ba1e846dca73c2e --- /dev/null +++ b/src/gpioa/ospeedr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OSPEEDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR15R { + bits: u8, +} +impl OSPEEDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR14R { + bits: u8, +} +impl OSPEEDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR13R { + bits: u8, +} +impl OSPEEDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR12R { + bits: u8, +} +impl OSPEEDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR11R { + bits: u8, +} +impl OSPEEDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR10R { + bits: u8, +} +impl OSPEEDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR9R { + bits: u8, +} +impl OSPEEDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR8R { + bits: u8, +} +impl OSPEEDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR7R { + bits: u8, +} +impl OSPEEDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR6R { + bits: u8, +} +impl OSPEEDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR5R { + bits: u8, +} +impl OSPEEDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR4R { + bits: u8, +} +impl OSPEEDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR3R { + bits: u8, +} +impl OSPEEDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR2R { + bits: u8, +} +impl OSPEEDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR1R { + bits: u8, +} +impl OSPEEDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR0R { + bits: u8, +} +impl OSPEEDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR15W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR14W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR13W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR12W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR11W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR10W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR9W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR8W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR7W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR6W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR5W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR4W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR3W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR2W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR1W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR0W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&self) -> OSPEEDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&self) -> OSPEEDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&self) -> OSPEEDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&self) -> OSPEEDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&self) -> OSPEEDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&self) -> OSPEEDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&self) -> OSPEEDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&self) -> OSPEEDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&self) -> OSPEEDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&self) -> OSPEEDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&self) -> OSPEEDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&self) -> OSPEEDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&self) -> OSPEEDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&self) -> OSPEEDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&self) -> OSPEEDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&self) -> OSPEEDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&mut self) -> _OSPEEDR15W { + _OSPEEDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&mut self) -> _OSPEEDR14W { + _OSPEEDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&mut self) -> _OSPEEDR13W { + _OSPEEDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&mut self) -> _OSPEEDR12W { + _OSPEEDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&mut self) -> _OSPEEDR11W { + _OSPEEDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&mut self) -> _OSPEEDR10W { + _OSPEEDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&mut self) -> _OSPEEDR9W { + _OSPEEDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&mut self) -> _OSPEEDR8W { + _OSPEEDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&mut self) -> _OSPEEDR7W { + _OSPEEDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&mut self) -> _OSPEEDR6W { + _OSPEEDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&mut self) -> _OSPEEDR5W { + _OSPEEDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&mut self) -> _OSPEEDR4W { + _OSPEEDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&mut self) -> _OSPEEDR3W { + _OSPEEDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&mut self) -> _OSPEEDR2W { + _OSPEEDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&mut self) -> _OSPEEDR1W { + _OSPEEDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&mut self) -> _OSPEEDR0W { + _OSPEEDR0W { w: self } + } +} diff --git a/src/gpioa/otyper/mod.rs b/src/gpioa/otyper/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b5cd09d505177afbbc62399488c69b7fad6598b --- /dev/null +++ b/src/gpioa/otyper/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OTYPER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OT15R { + bits: bool, +} +impl OT15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT14R { + bits: bool, +} +impl OT14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT13R { + bits: bool, +} +impl OT13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT12R { + bits: bool, +} +impl OT12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT11R { + bits: bool, +} +impl OT11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT10R { + bits: bool, +} +impl OT10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT9R { + bits: bool, +} +impl OT9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT8R { + bits: bool, +} +impl OT8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT7R { + bits: bool, +} +impl OT7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT6R { + bits: bool, +} +impl OT6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT5R { + bits: bool, +} +impl OT5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT4R { + bits: bool, +} +impl OT4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT3R { + bits: bool, +} +impl OT3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT2R { + bits: bool, +} +impl OT2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT1R { + bits: bool, +} +impl OT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT0R { + bits: bool, +} +impl OT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OT15W<'a> { + w: &'a mut W, +} +impl<'a> _OT15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT14W<'a> { + w: &'a mut W, +} +impl<'a> _OT14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT13W<'a> { + w: &'a mut W, +} +impl<'a> _OT13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT12W<'a> { + w: &'a mut W, +} +impl<'a> _OT12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT11W<'a> { + w: &'a mut W, +} +impl<'a> _OT11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT10W<'a> { + w: &'a mut W, +} +impl<'a> _OT10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT9W<'a> { + w: &'a mut W, +} +impl<'a> _OT9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT8W<'a> { + w: &'a mut W, +} +impl<'a> _OT8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT7W<'a> { + w: &'a mut W, +} +impl<'a> _OT7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT6W<'a> { + w: &'a mut W, +} +impl<'a> _OT6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT5W<'a> { + w: &'a mut W, +} +impl<'a> _OT5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT4W<'a> { + w: &'a mut W, +} +impl<'a> _OT4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT3W<'a> { + w: &'a mut W, +} +impl<'a> _OT3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT2W<'a> { + w: &'a mut W, +} +impl<'a> _OT2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT1W<'a> { + w: &'a mut W, +} +impl<'a> _OT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT0W<'a> { + w: &'a mut W, +} +impl<'a> _OT0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&self) -> OT15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT15R { bits } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&self) -> OT14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT14R { bits } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&self) -> OT13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT13R { bits } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&self) -> OT12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT12R { bits } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&self) -> OT11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT11R { bits } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&self) -> OT10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT10R { bits } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&self) -> OT9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT9R { bits } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&self) -> OT8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT8R { bits } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&self) -> OT7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT7R { bits } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&self) -> OT6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT6R { bits } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&self) -> OT5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT5R { bits } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&self) -> OT4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT4R { bits } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&self) -> OT3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT3R { bits } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&self) -> OT2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT2R { bits } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&self) -> OT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT1R { bits } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&self) -> OT0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&mut self) -> _OT15W { + _OT15W { w: self } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&mut self) -> _OT14W { + _OT14W { w: self } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&mut self) -> _OT13W { + _OT13W { w: self } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&mut self) -> _OT12W { + _OT12W { w: self } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&mut self) -> _OT11W { + _OT11W { w: self } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&mut self) -> _OT10W { + _OT10W { w: self } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&mut self) -> _OT9W { + _OT9W { w: self } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&mut self) -> _OT8W { + _OT8W { w: self } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&mut self) -> _OT7W { + _OT7W { w: self } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&mut self) -> _OT6W { + _OT6W { w: self } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&mut self) -> _OT5W { + _OT5W { w: self } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&mut self) -> _OT4W { + _OT4W { w: self } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&mut self) -> _OT3W { + _OT3W { w: self } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&mut self) -> _OT2W { + _OT2W { w: self } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&mut self) -> _OT1W { + _OT1W { w: self } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&mut self) -> _OT0W { + _OT0W { w: self } + } +} diff --git a/src/gpioa/pupdr/mod.rs b/src/gpioa/pupdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2a88561c406a57c796e1d8b094d14ce0c61648a8 --- /dev/null +++ b/src/gpioa/pupdr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PUPDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PUPDR15R { + bits: u8, +} +impl PUPDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR14R { + bits: u8, +} +impl PUPDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR13R { + bits: u8, +} +impl PUPDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR12R { + bits: u8, +} +impl PUPDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR11R { + bits: u8, +} +impl PUPDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR10R { + bits: u8, +} +impl PUPDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR9R { + bits: u8, +} +impl PUPDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR8R { + bits: u8, +} +impl PUPDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR7R { + bits: u8, +} +impl PUPDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR6R { + bits: u8, +} +impl PUPDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR5R { + bits: u8, +} +impl PUPDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR4R { + bits: u8, +} +impl PUPDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR3R { + bits: u8, +} +impl PUPDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR2R { + bits: u8, +} +impl PUPDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR1R { + bits: u8, +} +impl PUPDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR0R { + bits: u8, +} +impl PUPDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PUPDR15W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR14W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR13W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR12W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR11W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR10W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR9W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR8W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR7W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR6W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR5W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR4W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR3W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR2W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR1W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR0W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&self) -> PUPDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&self) -> PUPDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&self) -> PUPDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&self) -> PUPDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&self) -> PUPDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&self) -> PUPDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&self) -> PUPDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&self) -> PUPDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&self) -> PUPDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&self) -> PUPDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&self) -> PUPDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&self) -> PUPDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&self) -> PUPDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&self) -> PUPDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&self) -> PUPDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&self) -> PUPDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1677721600 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&mut self) -> _PUPDR15W { + _PUPDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&mut self) -> _PUPDR14W { + _PUPDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&mut self) -> _PUPDR13W { + _PUPDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&mut self) -> _PUPDR12W { + _PUPDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&mut self) -> _PUPDR11W { + _PUPDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&mut self) -> _PUPDR10W { + _PUPDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&mut self) -> _PUPDR9W { + _PUPDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&mut self) -> _PUPDR8W { + _PUPDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&mut self) -> _PUPDR7W { + _PUPDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&mut self) -> _PUPDR6W { + _PUPDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&mut self) -> _PUPDR5W { + _PUPDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&mut self) -> _PUPDR4W { + _PUPDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&mut self) -> _PUPDR3W { + _PUPDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&mut self) -> _PUPDR2W { + _PUPDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&mut self) -> _PUPDR1W { + _PUPDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&mut self) -> _PUPDR0W { + _PUPDR0W { w: self } + } +} diff --git a/src/gpiob/afrh/mod.rs b/src/gpiob/afrh/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2fa3c156601a21f55db69941b999372cb7c44fa3 --- /dev/null +++ b/src/gpiob/afrh/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRH { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRH15R { + bits: u8, +} +impl AFRH15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH14R { + bits: u8, +} +impl AFRH14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH13R { + bits: u8, +} +impl AFRH13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH12R { + bits: u8, +} +impl AFRH12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH11R { + bits: u8, +} +impl AFRH11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH10R { + bits: u8, +} +impl AFRH10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH9R { + bits: u8, +} +impl AFRH9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH8R { + bits: u8, +} +impl AFRH8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRH15W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH14W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH13W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH12W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH11W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH10W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH9W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH8W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&self) -> AFRH15R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH15R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&self) -> AFRH14R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH14R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&self) -> AFRH13R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH13R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&self) -> AFRH12R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH12R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&self) -> AFRH11R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH11R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&self) -> AFRH10R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH10R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&self) -> AFRH9R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH9R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&self) -> AFRH8R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH8R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&mut self) -> _AFRH15W { + _AFRH15W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&mut self) -> _AFRH14W { + _AFRH14W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&mut self) -> _AFRH13W { + _AFRH13W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&mut self) -> _AFRH12W { + _AFRH12W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&mut self) -> _AFRH11W { + _AFRH11W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&mut self) -> _AFRH10W { + _AFRH10W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&mut self) -> _AFRH9W { + _AFRH9W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&mut self) -> _AFRH8W { + _AFRH8W { w: self } + } +} diff --git a/src/gpiob/afrl/mod.rs b/src/gpiob/afrl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..630035c446d0c8a1259a7deff7a014fe582b903c --- /dev/null +++ b/src/gpiob/afrl/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRL7R { + bits: u8, +} +impl AFRL7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL6R { + bits: u8, +} +impl AFRL6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL5R { + bits: u8, +} +impl AFRL5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL4R { + bits: u8, +} +impl AFRL4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL3R { + bits: u8, +} +impl AFRL3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL2R { + bits: u8, +} +impl AFRL2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL1R { + bits: u8, +} +impl AFRL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL0R { + bits: u8, +} +impl AFRL0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRL7W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL6W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL5W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL4W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL3W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL2W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL1W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL0W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&self) -> AFRL7R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL7R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&self) -> AFRL6R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL6R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&self) -> AFRL5R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL5R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&self) -> AFRL4R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL4R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&self) -> AFRL3R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL3R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&self) -> AFRL2R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL2R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&self) -> AFRL1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL1R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&self) -> AFRL0R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&mut self) -> _AFRL7W { + _AFRL7W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&mut self) -> _AFRL6W { + _AFRL6W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&mut self) -> _AFRL5W { + _AFRL5W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&mut self) -> _AFRL4W { + _AFRL4W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&mut self) -> _AFRL3W { + _AFRL3W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&mut self) -> _AFRL2W { + _AFRL2W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&mut self) -> _AFRL1W { + _AFRL1W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&mut self) -> _AFRL0W { + _AFRL0W { w: self } + } +} diff --git a/src/gpiob/bsrr/mod.rs b/src/gpiob/bsrr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..246617bfc79601abd4543412ff6a478ee2fb7755 --- /dev/null +++ b/src/gpiob/bsrr/mod.rs @@ -0,0 +1,925 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BSRR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _BR15W<'a> { + w: &'a mut W, +} +impl<'a> _BR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR14W<'a> { + w: &'a mut W, +} +impl<'a> _BR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR13W<'a> { + w: &'a mut W, +} +impl<'a> _BR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR12W<'a> { + w: &'a mut W, +} +impl<'a> _BR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR11W<'a> { + w: &'a mut W, +} +impl<'a> _BR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR10W<'a> { + w: &'a mut W, +} +impl<'a> _BR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR9W<'a> { + w: &'a mut W, +} +impl<'a> _BR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR8W<'a> { + w: &'a mut W, +} +impl<'a> _BR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR7W<'a> { + w: &'a mut W, +} +impl<'a> _BR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR6W<'a> { + w: &'a mut W, +} +impl<'a> _BR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR5W<'a> { + w: &'a mut W, +} +impl<'a> _BR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR4W<'a> { + w: &'a mut W, +} +impl<'a> _BR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR3W<'a> { + w: &'a mut W, +} +impl<'a> _BR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR2W<'a> { + w: &'a mut W, +} +impl<'a> _BR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR1W<'a> { + w: &'a mut W, +} +impl<'a> _BR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR0W<'a> { + w: &'a mut W, +} +impl<'a> _BR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS15W<'a> { + w: &'a mut W, +} +impl<'a> _BS15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS14W<'a> { + w: &'a mut W, +} +impl<'a> _BS14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS13W<'a> { + w: &'a mut W, +} +impl<'a> _BS13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS12W<'a> { + w: &'a mut W, +} +impl<'a> _BS12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS11W<'a> { + w: &'a mut W, +} +impl<'a> _BS11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS10W<'a> { + w: &'a mut W, +} +impl<'a> _BS10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS9W<'a> { + w: &'a mut W, +} +impl<'a> _BS9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS8W<'a> { + w: &'a mut W, +} +impl<'a> _BS8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS7W<'a> { + w: &'a mut W, +} +impl<'a> _BS7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS6W<'a> { + w: &'a mut W, +} +impl<'a> _BS6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS5W<'a> { + w: &'a mut W, +} +impl<'a> _BS5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS4W<'a> { + w: &'a mut W, +} +impl<'a> _BS4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS3W<'a> { + w: &'a mut W, +} +impl<'a> _BS3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS2W<'a> { + w: &'a mut W, +} +impl<'a> _BS2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS1W<'a> { + w: &'a mut W, +} +impl<'a> _BS1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS0W<'a> { + w: &'a mut W, +} +impl<'a> _BS0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br15(&mut self) -> _BR15W { + _BR15W { w: self } + } + #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br14(&mut self) -> _BR14W { + _BR14W { w: self } + } + #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br13(&mut self) -> _BR13W { + _BR13W { w: self } + } + #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br12(&mut self) -> _BR12W { + _BR12W { w: self } + } + #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br11(&mut self) -> _BR11W { + _BR11W { w: self } + } + #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br10(&mut self) -> _BR10W { + _BR10W { w: self } + } + #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br9(&mut self) -> _BR9W { + _BR9W { w: self } + } + #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br8(&mut self) -> _BR8W { + _BR8W { w: self } + } + #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br7(&mut self) -> _BR7W { + _BR7W { w: self } + } + #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br6(&mut self) -> _BR6W { + _BR6W { w: self } + } + #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br5(&mut self) -> _BR5W { + _BR5W { w: self } + } + #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br4(&mut self) -> _BR4W { + _BR4W { w: self } + } + #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br3(&mut self) -> _BR3W { + _BR3W { w: self } + } + #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br2(&mut self) -> _BR2W { + _BR2W { w: self } + } + #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br1(&mut self) -> _BR1W { + _BR1W { w: self } + } + #[doc = "Bit 16 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn br0(&mut self) -> _BR0W { + _BR0W { w: self } + } + #[doc = "Bit 15 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs15(&mut self) -> _BS15W { + _BS15W { w: self } + } + #[doc = "Bit 14 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs14(&mut self) -> _BS14W { + _BS14W { w: self } + } + #[doc = "Bit 13 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs13(&mut self) -> _BS13W { + _BS13W { w: self } + } + #[doc = "Bit 12 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs12(&mut self) -> _BS12W { + _BS12W { w: self } + } + #[doc = "Bit 11 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs11(&mut self) -> _BS11W { + _BS11W { w: self } + } + #[doc = "Bit 10 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs10(&mut self) -> _BS10W { + _BS10W { w: self } + } + #[doc = "Bit 9 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs9(&mut self) -> _BS9W { + _BS9W { w: self } + } + #[doc = "Bit 8 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs8(&mut self) -> _BS8W { + _BS8W { w: self } + } + #[doc = "Bit 7 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs7(&mut self) -> _BS7W { + _BS7W { w: self } + } + #[doc = "Bit 6 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs6(&mut self) -> _BS6W { + _BS6W { w: self } + } + #[doc = "Bit 5 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs5(&mut self) -> _BS5W { + _BS5W { w: self } + } + #[doc = "Bit 4 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs4(&mut self) -> _BS4W { + _BS4W { w: self } + } + #[doc = "Bit 3 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs3(&mut self) -> _BS3W { + _BS3W { w: self } + } + #[doc = "Bit 2 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs2(&mut self) -> _BS2W { + _BS2W { w: self } + } + #[doc = "Bit 1 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs1(&mut self) -> _BS1W { + _BS1W { w: self } + } + #[doc = "Bit 0 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs0(&mut self) -> _BS0W { + _BS0W { w: self } + } +} diff --git a/src/gpiob/idr/mod.rs b/src/gpiob/idr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab2006bf57931967f67d50aff2687cf8574c203b --- /dev/null +++ b/src/gpiob/idr/mod.rs @@ -0,0 +1,516 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::IDR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct IDR15R { + bits: bool, +} +impl IDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR14R { + bits: bool, +} +impl IDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR13R { + bits: bool, +} +impl IDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR12R { + bits: bool, +} +impl IDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR11R { + bits: bool, +} +impl IDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR10R { + bits: bool, +} +impl IDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR9R { + bits: bool, +} +impl IDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR8R { + bits: bool, +} +impl IDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR7R { + bits: bool, +} +impl IDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR6R { + bits: bool, +} +impl IDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR5R { + bits: bool, +} +impl IDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR4R { + bits: bool, +} +impl IDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR3R { + bits: bool, +} +impl IDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR2R { + bits: bool, +} +impl IDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR1R { + bits: bool, +} +impl IDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR0R { + bits: bool, +} +impl IDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port input data (y = 0..15)"] + #[inline] + pub fn idr15(&self) -> IDR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR15R { bits } + } + #[doc = "Bit 14 - Port input data (y = 0..15)"] + #[inline] + pub fn idr14(&self) -> IDR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR14R { bits } + } + #[doc = "Bit 13 - Port input data (y = 0..15)"] + #[inline] + pub fn idr13(&self) -> IDR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR13R { bits } + } + #[doc = "Bit 12 - Port input data (y = 0..15)"] + #[inline] + pub fn idr12(&self) -> IDR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR12R { bits } + } + #[doc = "Bit 11 - Port input data (y = 0..15)"] + #[inline] + pub fn idr11(&self) -> IDR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR11R { bits } + } + #[doc = "Bit 10 - Port input data (y = 0..15)"] + #[inline] + pub fn idr10(&self) -> IDR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR10R { bits } + } + #[doc = "Bit 9 - Port input data (y = 0..15)"] + #[inline] + pub fn idr9(&self) -> IDR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR9R { bits } + } + #[doc = "Bit 8 - Port input data (y = 0..15)"] + #[inline] + pub fn idr8(&self) -> IDR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR8R { bits } + } + #[doc = "Bit 7 - Port input data (y = 0..15)"] + #[inline] + pub fn idr7(&self) -> IDR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR7R { bits } + } + #[doc = "Bit 6 - Port input data (y = 0..15)"] + #[inline] + pub fn idr6(&self) -> IDR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR6R { bits } + } + #[doc = "Bit 5 - Port input data (y = 0..15)"] + #[inline] + pub fn idr5(&self) -> IDR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR5R { bits } + } + #[doc = "Bit 4 - Port input data (y = 0..15)"] + #[inline] + pub fn idr4(&self) -> IDR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR4R { bits } + } + #[doc = "Bit 3 - Port input data (y = 0..15)"] + #[inline] + pub fn idr3(&self) -> IDR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR3R { bits } + } + #[doc = "Bit 2 - Port input data (y = 0..15)"] + #[inline] + pub fn idr2(&self) -> IDR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR2R { bits } + } + #[doc = "Bit 1 - Port input data (y = 0..15)"] + #[inline] + pub fn idr1(&self) -> IDR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR1R { bits } + } + #[doc = "Bit 0 - Port input data (y = 0..15)"] + #[inline] + pub fn idr0(&self) -> IDR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR0R { bits } + } +} diff --git a/src/gpiob/lckr/mod.rs b/src/gpiob/lckr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..76660a645cbfb96d5e6cf456fcff0f87a3fa2dbb --- /dev/null +++ b/src/gpiob/lckr/mod.rs @@ -0,0 +1,1067 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LCKR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LCKKR { + bits: bool, +} +impl LCKKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK15R { + bits: bool, +} +impl LCK15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK14R { + bits: bool, +} +impl LCK14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK13R { + bits: bool, +} +impl LCK13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK12R { + bits: bool, +} +impl LCK12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK11R { + bits: bool, +} +impl LCK11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK10R { + bits: bool, +} +impl LCK10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK9R { + bits: bool, +} +impl LCK9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK8R { + bits: bool, +} +impl LCK8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK7R { + bits: bool, +} +impl LCK7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK6R { + bits: bool, +} +impl LCK6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK5R { + bits: bool, +} +impl LCK5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK4R { + bits: bool, +} +impl LCK4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK3R { + bits: bool, +} +impl LCK3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK2R { + bits: bool, +} +impl LCK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK1R { + bits: bool, +} +impl LCK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK0R { + bits: bool, +} +impl LCK0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LCKKW<'a> { + w: &'a mut W, +} +impl<'a> _LCKKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK15W<'a> { + w: &'a mut W, +} +impl<'a> _LCK15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK14W<'a> { + w: &'a mut W, +} +impl<'a> _LCK14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK13W<'a> { + w: &'a mut W, +} +impl<'a> _LCK13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK12W<'a> { + w: &'a mut W, +} +impl<'a> _LCK12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK11W<'a> { + w: &'a mut W, +} +impl<'a> _LCK11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK10W<'a> { + w: &'a mut W, +} +impl<'a> _LCK10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK9W<'a> { + w: &'a mut W, +} +impl<'a> _LCK9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK8W<'a> { + w: &'a mut W, +} +impl<'a> _LCK8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK7W<'a> { + w: &'a mut W, +} +impl<'a> _LCK7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK6W<'a> { + w: &'a mut W, +} +impl<'a> _LCK6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK5W<'a> { + w: &'a mut W, +} +impl<'a> _LCK5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK4W<'a> { + w: &'a mut W, +} +impl<'a> _LCK4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK3W<'a> { + w: &'a mut W, +} +impl<'a> _LCK3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK2W<'a> { + w: &'a mut W, +} +impl<'a> _LCK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK1W<'a> { + w: &'a mut W, +} +impl<'a> _LCK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK0W<'a> { + w: &'a mut W, +} +impl<'a> _LCK0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&self) -> LCKKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCKKR { bits } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&self) -> LCK15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK15R { bits } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&self) -> LCK14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK14R { bits } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&self) -> LCK13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK13R { bits } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&self) -> LCK12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK12R { bits } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&self) -> LCK11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK11R { bits } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&self) -> LCK10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK10R { bits } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&self) -> LCK9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK9R { bits } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&self) -> LCK8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK8R { bits } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&self) -> LCK7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK7R { bits } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&self) -> LCK6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK6R { bits } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&self) -> LCK5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK5R { bits } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&self) -> LCK4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK4R { bits } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&self) -> LCK3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK3R { bits } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&self) -> LCK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK2R { bits } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&self) -> LCK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK1R { bits } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&self) -> LCK0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&mut self) -> _LCKKW { + _LCKKW { w: self } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&mut self) -> _LCK15W { + _LCK15W { w: self } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&mut self) -> _LCK14W { + _LCK14W { w: self } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&mut self) -> _LCK13W { + _LCK13W { w: self } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&mut self) -> _LCK12W { + _LCK12W { w: self } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&mut self) -> _LCK11W { + _LCK11W { w: self } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&mut self) -> _LCK10W { + _LCK10W { w: self } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&mut self) -> _LCK9W { + _LCK9W { w: self } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&mut self) -> _LCK8W { + _LCK8W { w: self } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&mut self) -> _LCK7W { + _LCK7W { w: self } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&mut self) -> _LCK6W { + _LCK6W { w: self } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&mut self) -> _LCK5W { + _LCK5W { w: self } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&mut self) -> _LCK4W { + _LCK4W { w: self } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&mut self) -> _LCK3W { + _LCK3W { w: self } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&mut self) -> _LCK2W { + _LCK2W { w: self } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&mut self) -> _LCK1W { + _LCK1W { w: self } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&mut self) -> _LCK0W { + _LCK0W { w: self } + } +} diff --git a/src/gpiob/mod.rs b/src/gpiob/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..048d6055d4f9cc1f13ef6b534676451c28c9a7ba --- /dev/null +++ b/src/gpiob/mod.rs @@ -0,0 +1,84 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - GPIO port mode register"] + pub moder: MODER, + #[doc = "0x04 - GPIO port output type register"] + pub otyper: OTYPER, + #[doc = "0x08 - GPIO port output speed register"] + pub ospeedr: OSPEEDR, + #[doc = "0x0c - GPIO port pull-up/pull-down register"] + pub pupdr: PUPDR, + #[doc = "0x10 - GPIO port input data register"] + pub idr: IDR, + #[doc = "0x14 - GPIO port output data register"] + pub odr: ODR, + #[doc = "0x18 - GPIO port bit set/reset register"] + pub bsrr: BSRR, + #[doc = "0x1c - GPIO port configuration lock register"] + pub lckr: LCKR, + #[doc = "0x20 - GPIO alternate function low register"] + pub afrl: AFRL, + #[doc = "0x24 - GPIO alternate function high register"] + pub afrh: AFRH, +} +#[doc = "GPIO port mode register"] +pub struct MODER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port mode register"] +pub mod moder; +#[doc = "GPIO port output type register"] +pub struct OTYPER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output type register"] +pub mod otyper; +#[doc = "GPIO port output speed register"] +pub struct OSPEEDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output speed register"] +pub mod ospeedr; +#[doc = "GPIO port pull-up/pull-down register"] +pub struct PUPDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port pull-up/pull-down register"] +pub mod pupdr; +#[doc = "GPIO port input data register"] +pub struct IDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port input data register"] +pub mod idr; +#[doc = "GPIO port output data register"] +pub struct ODR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output data register"] +pub mod odr; +#[doc = "GPIO port bit set/reset register"] +pub struct BSRR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port bit set/reset register"] +pub mod bsrr; +#[doc = "GPIO port configuration lock register"] +pub struct LCKR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port configuration lock register"] +pub mod lckr; +#[doc = "GPIO alternate function low register"] +pub struct AFRL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function low register"] +pub mod afrl; +#[doc = "GPIO alternate function high register"] +pub struct AFRH { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function high register"] +pub mod afrh; diff --git a/src/gpiob/moder/mod.rs b/src/gpiob/moder/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4ae2e800c624583a42c6956c2e3edbb713b7d3a7 --- /dev/null +++ b/src/gpiob/moder/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MODER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MODER15R { + bits: u8, +} +impl MODER15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER14R { + bits: u8, +} +impl MODER14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER13R { + bits: u8, +} +impl MODER13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER12R { + bits: u8, +} +impl MODER12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER11R { + bits: u8, +} +impl MODER11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER10R { + bits: u8, +} +impl MODER10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER9R { + bits: u8, +} +impl MODER9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER8R { + bits: u8, +} +impl MODER8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER7R { + bits: u8, +} +impl MODER7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER6R { + bits: u8, +} +impl MODER6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER5R { + bits: u8, +} +impl MODER5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER4R { + bits: u8, +} +impl MODER4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER3R { + bits: u8, +} +impl MODER3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER2R { + bits: u8, +} +impl MODER2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER1R { + bits: u8, +} +impl MODER1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER0R { + bits: u8, +} +impl MODER0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MODER15W<'a> { + w: &'a mut W, +} +impl<'a> _MODER15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER14W<'a> { + w: &'a mut W, +} +impl<'a> _MODER14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER13W<'a> { + w: &'a mut W, +} +impl<'a> _MODER13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER12W<'a> { + w: &'a mut W, +} +impl<'a> _MODER12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER11W<'a> { + w: &'a mut W, +} +impl<'a> _MODER11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER10W<'a> { + w: &'a mut W, +} +impl<'a> _MODER10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER9W<'a> { + w: &'a mut W, +} +impl<'a> _MODER9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER8W<'a> { + w: &'a mut W, +} +impl<'a> _MODER8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER7W<'a> { + w: &'a mut W, +} +impl<'a> _MODER7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER6W<'a> { + w: &'a mut W, +} +impl<'a> _MODER6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER5W<'a> { + w: &'a mut W, +} +impl<'a> _MODER5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER4W<'a> { + w: &'a mut W, +} +impl<'a> _MODER4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER3W<'a> { + w: &'a mut W, +} +impl<'a> _MODER3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER2W<'a> { + w: &'a mut W, +} +impl<'a> _MODER2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER1W<'a> { + w: &'a mut W, +} +impl<'a> _MODER1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER0W<'a> { + w: &'a mut W, +} +impl<'a> _MODER0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&self) -> MODER15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&self) -> MODER14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&self) -> MODER13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&self) -> MODER12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&self) -> MODER11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&self) -> MODER10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&self) -> MODER9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&self) -> MODER8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&self) -> MODER7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&self) -> MODER6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&self) -> MODER5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&self) -> MODER4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&self) -> MODER3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&self) -> MODER2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&self) -> MODER1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&self) -> MODER0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 640 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&mut self) -> _MODER15W { + _MODER15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&mut self) -> _MODER14W { + _MODER14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&mut self) -> _MODER13W { + _MODER13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&mut self) -> _MODER12W { + _MODER12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&mut self) -> _MODER11W { + _MODER11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&mut self) -> _MODER10W { + _MODER10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&mut self) -> _MODER9W { + _MODER9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&mut self) -> _MODER8W { + _MODER8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&mut self) -> _MODER7W { + _MODER7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&mut self) -> _MODER6W { + _MODER6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&mut self) -> _MODER5W { + _MODER5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&mut self) -> _MODER4W { + _MODER4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&mut self) -> _MODER3W { + _MODER3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&mut self) -> _MODER2W { + _MODER2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&mut self) -> _MODER1W { + _MODER1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&mut self) -> _MODER0W { + _MODER0W { w: self } + } +} diff --git a/src/gpiob/odr/mod.rs b/src/gpiob/odr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e06ac5caf011b0351b245bea4964cda77f34de78 --- /dev/null +++ b/src/gpiob/odr/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ODR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ODR15R { + bits: bool, +} +impl ODR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR14R { + bits: bool, +} +impl ODR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR13R { + bits: bool, +} +impl ODR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR12R { + bits: bool, +} +impl ODR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR11R { + bits: bool, +} +impl ODR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR10R { + bits: bool, +} +impl ODR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR9R { + bits: bool, +} +impl ODR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR8R { + bits: bool, +} +impl ODR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR7R { + bits: bool, +} +impl ODR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR6R { + bits: bool, +} +impl ODR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR5R { + bits: bool, +} +impl ODR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR4R { + bits: bool, +} +impl ODR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR3R { + bits: bool, +} +impl ODR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR2R { + bits: bool, +} +impl ODR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR1R { + bits: bool, +} +impl ODR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR0R { + bits: bool, +} +impl ODR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ODR15W<'a> { + w: &'a mut W, +} +impl<'a> _ODR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR14W<'a> { + w: &'a mut W, +} +impl<'a> _ODR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR13W<'a> { + w: &'a mut W, +} +impl<'a> _ODR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR12W<'a> { + w: &'a mut W, +} +impl<'a> _ODR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR11W<'a> { + w: &'a mut W, +} +impl<'a> _ODR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR10W<'a> { + w: &'a mut W, +} +impl<'a> _ODR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR9W<'a> { + w: &'a mut W, +} +impl<'a> _ODR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR8W<'a> { + w: &'a mut W, +} +impl<'a> _ODR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR7W<'a> { + w: &'a mut W, +} +impl<'a> _ODR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR6W<'a> { + w: &'a mut W, +} +impl<'a> _ODR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR5W<'a> { + w: &'a mut W, +} +impl<'a> _ODR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR4W<'a> { + w: &'a mut W, +} +impl<'a> _ODR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR3W<'a> { + w: &'a mut W, +} +impl<'a> _ODR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR2W<'a> { + w: &'a mut W, +} +impl<'a> _ODR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR1W<'a> { + w: &'a mut W, +} +impl<'a> _ODR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR0W<'a> { + w: &'a mut W, +} +impl<'a> _ODR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&self) -> ODR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR15R { bits } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&self) -> ODR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR14R { bits } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&self) -> ODR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR13R { bits } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&self) -> ODR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR12R { bits } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&self) -> ODR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR11R { bits } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&self) -> ODR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR10R { bits } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&self) -> ODR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR9R { bits } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&self) -> ODR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR8R { bits } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&self) -> ODR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR7R { bits } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&self) -> ODR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR6R { bits } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&self) -> ODR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR5R { bits } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&self) -> ODR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR4R { bits } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&self) -> ODR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR3R { bits } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&self) -> ODR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR2R { bits } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&self) -> ODR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR1R { bits } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&self) -> ODR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&mut self) -> _ODR15W { + _ODR15W { w: self } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&mut self) -> _ODR14W { + _ODR14W { w: self } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&mut self) -> _ODR13W { + _ODR13W { w: self } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&mut self) -> _ODR12W { + _ODR12W { w: self } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&mut self) -> _ODR11W { + _ODR11W { w: self } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&mut self) -> _ODR10W { + _ODR10W { w: self } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&mut self) -> _ODR9W { + _ODR9W { w: self } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&mut self) -> _ODR8W { + _ODR8W { w: self } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&mut self) -> _ODR7W { + _ODR7W { w: self } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&mut self) -> _ODR6W { + _ODR6W { w: self } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&mut self) -> _ODR5W { + _ODR5W { w: self } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&mut self) -> _ODR4W { + _ODR4W { w: self } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&mut self) -> _ODR3W { + _ODR3W { w: self } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&mut self) -> _ODR2W { + _ODR2W { w: self } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&mut self) -> _ODR1W { + _ODR1W { w: self } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&mut self) -> _ODR0W { + _ODR0W { w: self } + } +} diff --git a/src/gpiob/ospeedr/mod.rs b/src/gpiob/ospeedr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b627c029c9768ea5a0ec92ba31492c959d7a39b3 --- /dev/null +++ b/src/gpiob/ospeedr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OSPEEDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR15R { + bits: u8, +} +impl OSPEEDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR14R { + bits: u8, +} +impl OSPEEDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR13R { + bits: u8, +} +impl OSPEEDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR12R { + bits: u8, +} +impl OSPEEDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR11R { + bits: u8, +} +impl OSPEEDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR10R { + bits: u8, +} +impl OSPEEDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR9R { + bits: u8, +} +impl OSPEEDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR8R { + bits: u8, +} +impl OSPEEDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR7R { + bits: u8, +} +impl OSPEEDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR6R { + bits: u8, +} +impl OSPEEDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR5R { + bits: u8, +} +impl OSPEEDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR4R { + bits: u8, +} +impl OSPEEDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR3R { + bits: u8, +} +impl OSPEEDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR2R { + bits: u8, +} +impl OSPEEDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR1R { + bits: u8, +} +impl OSPEEDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR0R { + bits: u8, +} +impl OSPEEDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR15W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR14W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR13W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR12W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR11W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR10W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR9W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR8W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR7W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR6W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR5W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR4W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR3W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR2W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR1W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR0W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&self) -> OSPEEDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&self) -> OSPEEDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&self) -> OSPEEDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&self) -> OSPEEDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&self) -> OSPEEDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&self) -> OSPEEDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&self) -> OSPEEDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&self) -> OSPEEDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&self) -> OSPEEDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&self) -> OSPEEDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&self) -> OSPEEDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&self) -> OSPEEDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&self) -> OSPEEDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&self) -> OSPEEDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&self) -> OSPEEDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&self) -> OSPEEDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 192 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&mut self) -> _OSPEEDR15W { + _OSPEEDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&mut self) -> _OSPEEDR14W { + _OSPEEDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&mut self) -> _OSPEEDR13W { + _OSPEEDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&mut self) -> _OSPEEDR12W { + _OSPEEDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&mut self) -> _OSPEEDR11W { + _OSPEEDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&mut self) -> _OSPEEDR10W { + _OSPEEDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&mut self) -> _OSPEEDR9W { + _OSPEEDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&mut self) -> _OSPEEDR8W { + _OSPEEDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&mut self) -> _OSPEEDR7W { + _OSPEEDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&mut self) -> _OSPEEDR6W { + _OSPEEDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&mut self) -> _OSPEEDR5W { + _OSPEEDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&mut self) -> _OSPEEDR4W { + _OSPEEDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&mut self) -> _OSPEEDR3W { + _OSPEEDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&mut self) -> _OSPEEDR2W { + _OSPEEDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&mut self) -> _OSPEEDR1W { + _OSPEEDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&mut self) -> _OSPEEDR0W { + _OSPEEDR0W { w: self } + } +} diff --git a/src/gpiob/otyper/mod.rs b/src/gpiob/otyper/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b5cd09d505177afbbc62399488c69b7fad6598b --- /dev/null +++ b/src/gpiob/otyper/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OTYPER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OT15R { + bits: bool, +} +impl OT15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT14R { + bits: bool, +} +impl OT14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT13R { + bits: bool, +} +impl OT13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT12R { + bits: bool, +} +impl OT12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT11R { + bits: bool, +} +impl OT11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT10R { + bits: bool, +} +impl OT10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT9R { + bits: bool, +} +impl OT9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT8R { + bits: bool, +} +impl OT8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT7R { + bits: bool, +} +impl OT7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT6R { + bits: bool, +} +impl OT6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT5R { + bits: bool, +} +impl OT5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT4R { + bits: bool, +} +impl OT4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT3R { + bits: bool, +} +impl OT3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT2R { + bits: bool, +} +impl OT2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT1R { + bits: bool, +} +impl OT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT0R { + bits: bool, +} +impl OT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OT15W<'a> { + w: &'a mut W, +} +impl<'a> _OT15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT14W<'a> { + w: &'a mut W, +} +impl<'a> _OT14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT13W<'a> { + w: &'a mut W, +} +impl<'a> _OT13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT12W<'a> { + w: &'a mut W, +} +impl<'a> _OT12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT11W<'a> { + w: &'a mut W, +} +impl<'a> _OT11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT10W<'a> { + w: &'a mut W, +} +impl<'a> _OT10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT9W<'a> { + w: &'a mut W, +} +impl<'a> _OT9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT8W<'a> { + w: &'a mut W, +} +impl<'a> _OT8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT7W<'a> { + w: &'a mut W, +} +impl<'a> _OT7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT6W<'a> { + w: &'a mut W, +} +impl<'a> _OT6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT5W<'a> { + w: &'a mut W, +} +impl<'a> _OT5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT4W<'a> { + w: &'a mut W, +} +impl<'a> _OT4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT3W<'a> { + w: &'a mut W, +} +impl<'a> _OT3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT2W<'a> { + w: &'a mut W, +} +impl<'a> _OT2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT1W<'a> { + w: &'a mut W, +} +impl<'a> _OT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT0W<'a> { + w: &'a mut W, +} +impl<'a> _OT0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&self) -> OT15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT15R { bits } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&self) -> OT14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT14R { bits } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&self) -> OT13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT13R { bits } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&self) -> OT12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT12R { bits } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&self) -> OT11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT11R { bits } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&self) -> OT10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT10R { bits } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&self) -> OT9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT9R { bits } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&self) -> OT8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT8R { bits } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&self) -> OT7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT7R { bits } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&self) -> OT6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT6R { bits } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&self) -> OT5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT5R { bits } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&self) -> OT4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT4R { bits } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&self) -> OT3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT3R { bits } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&self) -> OT2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT2R { bits } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&self) -> OT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT1R { bits } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&self) -> OT0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&mut self) -> _OT15W { + _OT15W { w: self } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&mut self) -> _OT14W { + _OT14W { w: self } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&mut self) -> _OT13W { + _OT13W { w: self } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&mut self) -> _OT12W { + _OT12W { w: self } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&mut self) -> _OT11W { + _OT11W { w: self } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&mut self) -> _OT10W { + _OT10W { w: self } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&mut self) -> _OT9W { + _OT9W { w: self } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&mut self) -> _OT8W { + _OT8W { w: self } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&mut self) -> _OT7W { + _OT7W { w: self } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&mut self) -> _OT6W { + _OT6W { w: self } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&mut self) -> _OT5W { + _OT5W { w: self } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&mut self) -> _OT4W { + _OT4W { w: self } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&mut self) -> _OT3W { + _OT3W { w: self } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&mut self) -> _OT2W { + _OT2W { w: self } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&mut self) -> _OT1W { + _OT1W { w: self } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&mut self) -> _OT0W { + _OT0W { w: self } + } +} diff --git a/src/gpiob/pupdr/mod.rs b/src/gpiob/pupdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8a563a497efc8131fc90ae76ffad59b903569a38 --- /dev/null +++ b/src/gpiob/pupdr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PUPDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PUPDR15R { + bits: u8, +} +impl PUPDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR14R { + bits: u8, +} +impl PUPDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR13R { + bits: u8, +} +impl PUPDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR12R { + bits: u8, +} +impl PUPDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR11R { + bits: u8, +} +impl PUPDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR10R { + bits: u8, +} +impl PUPDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR9R { + bits: u8, +} +impl PUPDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR8R { + bits: u8, +} +impl PUPDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR7R { + bits: u8, +} +impl PUPDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR6R { + bits: u8, +} +impl PUPDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR5R { + bits: u8, +} +impl PUPDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR4R { + bits: u8, +} +impl PUPDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR3R { + bits: u8, +} +impl PUPDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR2R { + bits: u8, +} +impl PUPDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR1R { + bits: u8, +} +impl PUPDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR0R { + bits: u8, +} +impl PUPDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PUPDR15W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR14W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR13W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR12W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR11W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR10W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR9W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR8W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR7W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR6W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR5W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR4W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR3W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR2W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR1W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR0W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&self) -> PUPDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&self) -> PUPDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&self) -> PUPDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&self) -> PUPDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&self) -> PUPDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&self) -> PUPDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&self) -> PUPDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&self) -> PUPDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&self) -> PUPDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&self) -> PUPDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&self) -> PUPDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&self) -> PUPDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&self) -> PUPDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&self) -> PUPDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&self) -> PUPDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&self) -> PUPDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 256 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&mut self) -> _PUPDR15W { + _PUPDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&mut self) -> _PUPDR14W { + _PUPDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&mut self) -> _PUPDR13W { + _PUPDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&mut self) -> _PUPDR12W { + _PUPDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&mut self) -> _PUPDR11W { + _PUPDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&mut self) -> _PUPDR10W { + _PUPDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&mut self) -> _PUPDR9W { + _PUPDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&mut self) -> _PUPDR8W { + _PUPDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&mut self) -> _PUPDR7W { + _PUPDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&mut self) -> _PUPDR6W { + _PUPDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&mut self) -> _PUPDR5W { + _PUPDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&mut self) -> _PUPDR4W { + _PUPDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&mut self) -> _PUPDR3W { + _PUPDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&mut self) -> _PUPDR2W { + _PUPDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&mut self) -> _PUPDR1W { + _PUPDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&mut self) -> _PUPDR0W { + _PUPDR0W { w: self } + } +} diff --git a/src/gpioh/afrh/mod.rs b/src/gpioh/afrh/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2fa3c156601a21f55db69941b999372cb7c44fa3 --- /dev/null +++ b/src/gpioh/afrh/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRH { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRH15R { + bits: u8, +} +impl AFRH15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH14R { + bits: u8, +} +impl AFRH14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH13R { + bits: u8, +} +impl AFRH13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH12R { + bits: u8, +} +impl AFRH12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH11R { + bits: u8, +} +impl AFRH11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH10R { + bits: u8, +} +impl AFRH10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH9R { + bits: u8, +} +impl AFRH9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRH8R { + bits: u8, +} +impl AFRH8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRH15W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH14W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH13W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH12W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH11W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH10W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH9W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRH8W<'a> { + w: &'a mut W, +} +impl<'a> _AFRH8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&self) -> AFRH15R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH15R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&self) -> AFRH14R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH14R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&self) -> AFRH13R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH13R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&self) -> AFRH12R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH12R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&self) -> AFRH11R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH11R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&self) -> AFRH10R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH10R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&self) -> AFRH9R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH9R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&self) -> AFRH8R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRH8R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh15(&mut self) -> _AFRH15W { + _AFRH15W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh14(&mut self) -> _AFRH14W { + _AFRH14W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh13(&mut self) -> _AFRH13W { + _AFRH13W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh12(&mut self) -> _AFRH12W { + _AFRH12W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh11(&mut self) -> _AFRH11W { + _AFRH11W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh10(&mut self) -> _AFRH10W { + _AFRH10W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh9(&mut self) -> _AFRH9W { + _AFRH9W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] + #[inline] + pub fn afrh8(&mut self) -> _AFRH8W { + _AFRH8W { w: self } + } +} diff --git a/src/gpioh/afrl/mod.rs b/src/gpioh/afrl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..630035c446d0c8a1259a7deff7a014fe582b903c --- /dev/null +++ b/src/gpioh/afrl/mod.rs @@ -0,0 +1,392 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AFRL7R { + bits: u8, +} +impl AFRL7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL6R { + bits: u8, +} +impl AFRL6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL5R { + bits: u8, +} +impl AFRL5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL4R { + bits: u8, +} +impl AFRL4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL3R { + bits: u8, +} +impl AFRL3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL2R { + bits: u8, +} +impl AFRL2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL1R { + bits: u8, +} +impl AFRL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AFRL0R { + bits: u8, +} +impl AFRL0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _AFRL7W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL6W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL5W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL4W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL3W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL2W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL1W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFRL0W<'a> { + w: &'a mut W, +} +impl<'a> _AFRL0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&self) -> AFRL7R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL7R { bits } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&self) -> AFRL6R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL6R { bits } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&self) -> AFRL5R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL5R { bits } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&self) -> AFRL4R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL4R { bits } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&self) -> AFRL3R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL3R { bits } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&self) -> AFRL2R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL2R { bits } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&self) -> AFRL1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL1R { bits } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&self) -> AFRL0R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + AFRL0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl7(&mut self) -> _AFRL7W { + _AFRL7W { w: self } + } + #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl6(&mut self) -> _AFRL6W { + _AFRL6W { w: self } + } + #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl5(&mut self) -> _AFRL5W { + _AFRL5W { w: self } + } + #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl4(&mut self) -> _AFRL4W { + _AFRL4W { w: self } + } + #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl3(&mut self) -> _AFRL3W { + _AFRL3W { w: self } + } + #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl2(&mut self) -> _AFRL2W { + _AFRL2W { w: self } + } + #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl1(&mut self) -> _AFRL1W { + _AFRL1W { w: self } + } + #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] + #[inline] + pub fn afrl0(&mut self) -> _AFRL0W { + _AFRL0W { w: self } + } +} diff --git a/src/gpioh/bsrr/mod.rs b/src/gpioh/bsrr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..246617bfc79601abd4543412ff6a478ee2fb7755 --- /dev/null +++ b/src/gpioh/bsrr/mod.rs @@ -0,0 +1,925 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BSRR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _BR15W<'a> { + w: &'a mut W, +} +impl<'a> _BR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR14W<'a> { + w: &'a mut W, +} +impl<'a> _BR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR13W<'a> { + w: &'a mut W, +} +impl<'a> _BR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR12W<'a> { + w: &'a mut W, +} +impl<'a> _BR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR11W<'a> { + w: &'a mut W, +} +impl<'a> _BR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR10W<'a> { + w: &'a mut W, +} +impl<'a> _BR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR9W<'a> { + w: &'a mut W, +} +impl<'a> _BR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR8W<'a> { + w: &'a mut W, +} +impl<'a> _BR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR7W<'a> { + w: &'a mut W, +} +impl<'a> _BR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR6W<'a> { + w: &'a mut W, +} +impl<'a> _BR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR5W<'a> { + w: &'a mut W, +} +impl<'a> _BR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR4W<'a> { + w: &'a mut W, +} +impl<'a> _BR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR3W<'a> { + w: &'a mut W, +} +impl<'a> _BR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR2W<'a> { + w: &'a mut W, +} +impl<'a> _BR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR1W<'a> { + w: &'a mut W, +} +impl<'a> _BR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BR0W<'a> { + w: &'a mut W, +} +impl<'a> _BR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS15W<'a> { + w: &'a mut W, +} +impl<'a> _BS15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS14W<'a> { + w: &'a mut W, +} +impl<'a> _BS14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS13W<'a> { + w: &'a mut W, +} +impl<'a> _BS13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS12W<'a> { + w: &'a mut W, +} +impl<'a> _BS12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS11W<'a> { + w: &'a mut W, +} +impl<'a> _BS11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS10W<'a> { + w: &'a mut W, +} +impl<'a> _BS10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS9W<'a> { + w: &'a mut W, +} +impl<'a> _BS9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS8W<'a> { + w: &'a mut W, +} +impl<'a> _BS8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS7W<'a> { + w: &'a mut W, +} +impl<'a> _BS7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS6W<'a> { + w: &'a mut W, +} +impl<'a> _BS6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS5W<'a> { + w: &'a mut W, +} +impl<'a> _BS5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS4W<'a> { + w: &'a mut W, +} +impl<'a> _BS4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS3W<'a> { + w: &'a mut W, +} +impl<'a> _BS3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS2W<'a> { + w: &'a mut W, +} +impl<'a> _BS2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS1W<'a> { + w: &'a mut W, +} +impl<'a> _BS1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BS0W<'a> { + w: &'a mut W, +} +impl<'a> _BS0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br15(&mut self) -> _BR15W { + _BR15W { w: self } + } + #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br14(&mut self) -> _BR14W { + _BR14W { w: self } + } + #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br13(&mut self) -> _BR13W { + _BR13W { w: self } + } + #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br12(&mut self) -> _BR12W { + _BR12W { w: self } + } + #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br11(&mut self) -> _BR11W { + _BR11W { w: self } + } + #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br10(&mut self) -> _BR10W { + _BR10W { w: self } + } + #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br9(&mut self) -> _BR9W { + _BR9W { w: self } + } + #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br8(&mut self) -> _BR8W { + _BR8W { w: self } + } + #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br7(&mut self) -> _BR7W { + _BR7W { w: self } + } + #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br6(&mut self) -> _BR6W { + _BR6W { w: self } + } + #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br5(&mut self) -> _BR5W { + _BR5W { w: self } + } + #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br4(&mut self) -> _BR4W { + _BR4W { w: self } + } + #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br3(&mut self) -> _BR3W { + _BR3W { w: self } + } + #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br2(&mut self) -> _BR2W { + _BR2W { w: self } + } + #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"] + #[inline] + pub fn br1(&mut self) -> _BR1W { + _BR1W { w: self } + } + #[doc = "Bit 16 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn br0(&mut self) -> _BR0W { + _BR0W { w: self } + } + #[doc = "Bit 15 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs15(&mut self) -> _BS15W { + _BS15W { w: self } + } + #[doc = "Bit 14 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs14(&mut self) -> _BS14W { + _BS14W { w: self } + } + #[doc = "Bit 13 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs13(&mut self) -> _BS13W { + _BS13W { w: self } + } + #[doc = "Bit 12 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs12(&mut self) -> _BS12W { + _BS12W { w: self } + } + #[doc = "Bit 11 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs11(&mut self) -> _BS11W { + _BS11W { w: self } + } + #[doc = "Bit 10 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs10(&mut self) -> _BS10W { + _BS10W { w: self } + } + #[doc = "Bit 9 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs9(&mut self) -> _BS9W { + _BS9W { w: self } + } + #[doc = "Bit 8 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs8(&mut self) -> _BS8W { + _BS8W { w: self } + } + #[doc = "Bit 7 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs7(&mut self) -> _BS7W { + _BS7W { w: self } + } + #[doc = "Bit 6 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs6(&mut self) -> _BS6W { + _BS6W { w: self } + } + #[doc = "Bit 5 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs5(&mut self) -> _BS5W { + _BS5W { w: self } + } + #[doc = "Bit 4 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs4(&mut self) -> _BS4W { + _BS4W { w: self } + } + #[doc = "Bit 3 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs3(&mut self) -> _BS3W { + _BS3W { w: self } + } + #[doc = "Bit 2 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs2(&mut self) -> _BS2W { + _BS2W { w: self } + } + #[doc = "Bit 1 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs1(&mut self) -> _BS1W { + _BS1W { w: self } + } + #[doc = "Bit 0 - Port x set bit y (y= 0..15)"] + #[inline] + pub fn bs0(&mut self) -> _BS0W { + _BS0W { w: self } + } +} diff --git a/src/gpioh/idr/mod.rs b/src/gpioh/idr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ab2006bf57931967f67d50aff2687cf8574c203b --- /dev/null +++ b/src/gpioh/idr/mod.rs @@ -0,0 +1,516 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::IDR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct IDR15R { + bits: bool, +} +impl IDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR14R { + bits: bool, +} +impl IDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR13R { + bits: bool, +} +impl IDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR12R { + bits: bool, +} +impl IDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR11R { + bits: bool, +} +impl IDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR10R { + bits: bool, +} +impl IDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR9R { + bits: bool, +} +impl IDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR8R { + bits: bool, +} +impl IDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR7R { + bits: bool, +} +impl IDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR6R { + bits: bool, +} +impl IDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR5R { + bits: bool, +} +impl IDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR4R { + bits: bool, +} +impl IDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR3R { + bits: bool, +} +impl IDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR2R { + bits: bool, +} +impl IDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR1R { + bits: bool, +} +impl IDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDR0R { + bits: bool, +} +impl IDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port input data (y = 0..15)"] + #[inline] + pub fn idr15(&self) -> IDR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR15R { bits } + } + #[doc = "Bit 14 - Port input data (y = 0..15)"] + #[inline] + pub fn idr14(&self) -> IDR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR14R { bits } + } + #[doc = "Bit 13 - Port input data (y = 0..15)"] + #[inline] + pub fn idr13(&self) -> IDR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR13R { bits } + } + #[doc = "Bit 12 - Port input data (y = 0..15)"] + #[inline] + pub fn idr12(&self) -> IDR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR12R { bits } + } + #[doc = "Bit 11 - Port input data (y = 0..15)"] + #[inline] + pub fn idr11(&self) -> IDR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR11R { bits } + } + #[doc = "Bit 10 - Port input data (y = 0..15)"] + #[inline] + pub fn idr10(&self) -> IDR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR10R { bits } + } + #[doc = "Bit 9 - Port input data (y = 0..15)"] + #[inline] + pub fn idr9(&self) -> IDR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR9R { bits } + } + #[doc = "Bit 8 - Port input data (y = 0..15)"] + #[inline] + pub fn idr8(&self) -> IDR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR8R { bits } + } + #[doc = "Bit 7 - Port input data (y = 0..15)"] + #[inline] + pub fn idr7(&self) -> IDR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR7R { bits } + } + #[doc = "Bit 6 - Port input data (y = 0..15)"] + #[inline] + pub fn idr6(&self) -> IDR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR6R { bits } + } + #[doc = "Bit 5 - Port input data (y = 0..15)"] + #[inline] + pub fn idr5(&self) -> IDR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR5R { bits } + } + #[doc = "Bit 4 - Port input data (y = 0..15)"] + #[inline] + pub fn idr4(&self) -> IDR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR4R { bits } + } + #[doc = "Bit 3 - Port input data (y = 0..15)"] + #[inline] + pub fn idr3(&self) -> IDR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR3R { bits } + } + #[doc = "Bit 2 - Port input data (y = 0..15)"] + #[inline] + pub fn idr2(&self) -> IDR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR2R { bits } + } + #[doc = "Bit 1 - Port input data (y = 0..15)"] + #[inline] + pub fn idr1(&self) -> IDR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR1R { bits } + } + #[doc = "Bit 0 - Port input data (y = 0..15)"] + #[inline] + pub fn idr0(&self) -> IDR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDR0R { bits } + } +} diff --git a/src/gpioh/lckr/mod.rs b/src/gpioh/lckr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..76660a645cbfb96d5e6cf456fcff0f87a3fa2dbb --- /dev/null +++ b/src/gpioh/lckr/mod.rs @@ -0,0 +1,1067 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LCKR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LCKKR { + bits: bool, +} +impl LCKKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK15R { + bits: bool, +} +impl LCK15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK14R { + bits: bool, +} +impl LCK14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK13R { + bits: bool, +} +impl LCK13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK12R { + bits: bool, +} +impl LCK12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK11R { + bits: bool, +} +impl LCK11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK10R { + bits: bool, +} +impl LCK10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK9R { + bits: bool, +} +impl LCK9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK8R { + bits: bool, +} +impl LCK8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK7R { + bits: bool, +} +impl LCK7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK6R { + bits: bool, +} +impl LCK6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK5R { + bits: bool, +} +impl LCK5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK4R { + bits: bool, +} +impl LCK4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK3R { + bits: bool, +} +impl LCK3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK2R { + bits: bool, +} +impl LCK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK1R { + bits: bool, +} +impl LCK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LCK0R { + bits: bool, +} +impl LCK0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LCKKW<'a> { + w: &'a mut W, +} +impl<'a> _LCKKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK15W<'a> { + w: &'a mut W, +} +impl<'a> _LCK15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK14W<'a> { + w: &'a mut W, +} +impl<'a> _LCK14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK13W<'a> { + w: &'a mut W, +} +impl<'a> _LCK13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK12W<'a> { + w: &'a mut W, +} +impl<'a> _LCK12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK11W<'a> { + w: &'a mut W, +} +impl<'a> _LCK11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK10W<'a> { + w: &'a mut W, +} +impl<'a> _LCK10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK9W<'a> { + w: &'a mut W, +} +impl<'a> _LCK9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK8W<'a> { + w: &'a mut W, +} +impl<'a> _LCK8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK7W<'a> { + w: &'a mut W, +} +impl<'a> _LCK7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK6W<'a> { + w: &'a mut W, +} +impl<'a> _LCK6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK5W<'a> { + w: &'a mut W, +} +impl<'a> _LCK5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK4W<'a> { + w: &'a mut W, +} +impl<'a> _LCK4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK3W<'a> { + w: &'a mut W, +} +impl<'a> _LCK3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK2W<'a> { + w: &'a mut W, +} +impl<'a> _LCK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK1W<'a> { + w: &'a mut W, +} +impl<'a> _LCK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LCK0W<'a> { + w: &'a mut W, +} +impl<'a> _LCK0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&self) -> LCKKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCKKR { bits } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&self) -> LCK15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK15R { bits } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&self) -> LCK14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK14R { bits } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&self) -> LCK13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK13R { bits } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&self) -> LCK12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK12R { bits } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&self) -> LCK11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK11R { bits } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&self) -> LCK10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK10R { bits } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&self) -> LCK9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK9R { bits } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&self) -> LCK8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK8R { bits } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&self) -> LCK7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK7R { bits } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&self) -> LCK6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK6R { bits } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&self) -> LCK5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK5R { bits } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&self) -> LCK4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK4R { bits } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&self) -> LCK3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK3R { bits } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&self) -> LCK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK2R { bits } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&self) -> LCK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK1R { bits } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&self) -> LCK0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LCK0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lckk(&mut self) -> _LCKKW { + _LCKKW { w: self } + } + #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck15(&mut self) -> _LCK15W { + _LCK15W { w: self } + } + #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck14(&mut self) -> _LCK14W { + _LCK14W { w: self } + } + #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck13(&mut self) -> _LCK13W { + _LCK13W { w: self } + } + #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck12(&mut self) -> _LCK12W { + _LCK12W { w: self } + } + #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck11(&mut self) -> _LCK11W { + _LCK11W { w: self } + } + #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck10(&mut self) -> _LCK10W { + _LCK10W { w: self } + } + #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck9(&mut self) -> _LCK9W { + _LCK9W { w: self } + } + #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck8(&mut self) -> _LCK8W { + _LCK8W { w: self } + } + #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck7(&mut self) -> _LCK7W { + _LCK7W { w: self } + } + #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck6(&mut self) -> _LCK6W { + _LCK6W { w: self } + } + #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck5(&mut self) -> _LCK5W { + _LCK5W { w: self } + } + #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck4(&mut self) -> _LCK4W { + _LCK4W { w: self } + } + #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck3(&mut self) -> _LCK3W { + _LCK3W { w: self } + } + #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck2(&mut self) -> _LCK2W { + _LCK2W { w: self } + } + #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck1(&mut self) -> _LCK1W { + _LCK1W { w: self } + } + #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] + #[inline] + pub fn lck0(&mut self) -> _LCK0W { + _LCK0W { w: self } + } +} diff --git a/src/gpioh/mod.rs b/src/gpioh/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..048d6055d4f9cc1f13ef6b534676451c28c9a7ba --- /dev/null +++ b/src/gpioh/mod.rs @@ -0,0 +1,84 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - GPIO port mode register"] + pub moder: MODER, + #[doc = "0x04 - GPIO port output type register"] + pub otyper: OTYPER, + #[doc = "0x08 - GPIO port output speed register"] + pub ospeedr: OSPEEDR, + #[doc = "0x0c - GPIO port pull-up/pull-down register"] + pub pupdr: PUPDR, + #[doc = "0x10 - GPIO port input data register"] + pub idr: IDR, + #[doc = "0x14 - GPIO port output data register"] + pub odr: ODR, + #[doc = "0x18 - GPIO port bit set/reset register"] + pub bsrr: BSRR, + #[doc = "0x1c - GPIO port configuration lock register"] + pub lckr: LCKR, + #[doc = "0x20 - GPIO alternate function low register"] + pub afrl: AFRL, + #[doc = "0x24 - GPIO alternate function high register"] + pub afrh: AFRH, +} +#[doc = "GPIO port mode register"] +pub struct MODER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port mode register"] +pub mod moder; +#[doc = "GPIO port output type register"] +pub struct OTYPER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output type register"] +pub mod otyper; +#[doc = "GPIO port output speed register"] +pub struct OSPEEDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output speed register"] +pub mod ospeedr; +#[doc = "GPIO port pull-up/pull-down register"] +pub struct PUPDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port pull-up/pull-down register"] +pub mod pupdr; +#[doc = "GPIO port input data register"] +pub struct IDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port input data register"] +pub mod idr; +#[doc = "GPIO port output data register"] +pub struct ODR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port output data register"] +pub mod odr; +#[doc = "GPIO port bit set/reset register"] +pub struct BSRR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port bit set/reset register"] +pub mod bsrr; +#[doc = "GPIO port configuration lock register"] +pub struct LCKR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO port configuration lock register"] +pub mod lckr; +#[doc = "GPIO alternate function low register"] +pub struct AFRL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function low register"] +pub mod afrl; +#[doc = "GPIO alternate function high register"] +pub struct AFRH { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "GPIO alternate function high register"] +pub mod afrh; diff --git a/src/gpioh/moder/mod.rs b/src/gpioh/moder/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b7a2dedde0cce699ff155068b25a37caeccfd8b3 --- /dev/null +++ b/src/gpioh/moder/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MODER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MODER15R { + bits: u8, +} +impl MODER15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER14R { + bits: u8, +} +impl MODER14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER13R { + bits: u8, +} +impl MODER13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER12R { + bits: u8, +} +impl MODER12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER11R { + bits: u8, +} +impl MODER11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER10R { + bits: u8, +} +impl MODER10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER9R { + bits: u8, +} +impl MODER9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER8R { + bits: u8, +} +impl MODER8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER7R { + bits: u8, +} +impl MODER7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER6R { + bits: u8, +} +impl MODER6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER5R { + bits: u8, +} +impl MODER5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER4R { + bits: u8, +} +impl MODER4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER3R { + bits: u8, +} +impl MODER3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER2R { + bits: u8, +} +impl MODER2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER1R { + bits: u8, +} +impl MODER1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER0R { + bits: u8, +} +impl MODER0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MODER15W<'a> { + w: &'a mut W, +} +impl<'a> _MODER15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER14W<'a> { + w: &'a mut W, +} +impl<'a> _MODER14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER13W<'a> { + w: &'a mut W, +} +impl<'a> _MODER13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER12W<'a> { + w: &'a mut W, +} +impl<'a> _MODER12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER11W<'a> { + w: &'a mut W, +} +impl<'a> _MODER11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER10W<'a> { + w: &'a mut W, +} +impl<'a> _MODER10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER9W<'a> { + w: &'a mut W, +} +impl<'a> _MODER9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER8W<'a> { + w: &'a mut W, +} +impl<'a> _MODER8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER7W<'a> { + w: &'a mut W, +} +impl<'a> _MODER7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER6W<'a> { + w: &'a mut W, +} +impl<'a> _MODER6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER5W<'a> { + w: &'a mut W, +} +impl<'a> _MODER5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER4W<'a> { + w: &'a mut W, +} +impl<'a> _MODER4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER3W<'a> { + w: &'a mut W, +} +impl<'a> _MODER3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER2W<'a> { + w: &'a mut W, +} +impl<'a> _MODER2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER1W<'a> { + w: &'a mut W, +} +impl<'a> _MODER1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODER0W<'a> { + w: &'a mut W, +} +impl<'a> _MODER0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&self) -> MODER15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&self) -> MODER14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&self) -> MODER13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&self) -> MODER12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&self) -> MODER11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&self) -> MODER10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&self) -> MODER9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&self) -> MODER8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&self) -> MODER7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&self) -> MODER6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&self) -> MODER5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&self) -> MODER4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&self) -> MODER3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&self) -> MODER2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&self) -> MODER1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&self) -> MODER0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder15(&mut self) -> _MODER15W { + _MODER15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder14(&mut self) -> _MODER14W { + _MODER14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder13(&mut self) -> _MODER13W { + _MODER13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder12(&mut self) -> _MODER12W { + _MODER12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder11(&mut self) -> _MODER11W { + _MODER11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder10(&mut self) -> _MODER10W { + _MODER10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder9(&mut self) -> _MODER9W { + _MODER9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder8(&mut self) -> _MODER8W { + _MODER8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder7(&mut self) -> _MODER7W { + _MODER7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder6(&mut self) -> _MODER6W { + _MODER6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder5(&mut self) -> _MODER5W { + _MODER5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder4(&mut self) -> _MODER4W { + _MODER4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder3(&mut self) -> _MODER3W { + _MODER3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder2(&mut self) -> _MODER2W { + _MODER2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder1(&mut self) -> _MODER1W { + _MODER1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn moder0(&mut self) -> _MODER0W { + _MODER0W { w: self } + } +} diff --git a/src/gpioh/odr/mod.rs b/src/gpioh/odr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e06ac5caf011b0351b245bea4964cda77f34de78 --- /dev/null +++ b/src/gpioh/odr/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ODR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ODR15R { + bits: bool, +} +impl ODR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR14R { + bits: bool, +} +impl ODR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR13R { + bits: bool, +} +impl ODR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR12R { + bits: bool, +} +impl ODR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR11R { + bits: bool, +} +impl ODR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR10R { + bits: bool, +} +impl ODR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR9R { + bits: bool, +} +impl ODR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR8R { + bits: bool, +} +impl ODR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR7R { + bits: bool, +} +impl ODR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR6R { + bits: bool, +} +impl ODR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR5R { + bits: bool, +} +impl ODR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR4R { + bits: bool, +} +impl ODR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR3R { + bits: bool, +} +impl ODR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR2R { + bits: bool, +} +impl ODR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR1R { + bits: bool, +} +impl ODR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODR0R { + bits: bool, +} +impl ODR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ODR15W<'a> { + w: &'a mut W, +} +impl<'a> _ODR15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR14W<'a> { + w: &'a mut W, +} +impl<'a> _ODR14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR13W<'a> { + w: &'a mut W, +} +impl<'a> _ODR13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR12W<'a> { + w: &'a mut W, +} +impl<'a> _ODR12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR11W<'a> { + w: &'a mut W, +} +impl<'a> _ODR11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR10W<'a> { + w: &'a mut W, +} +impl<'a> _ODR10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR9W<'a> { + w: &'a mut W, +} +impl<'a> _ODR9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR8W<'a> { + w: &'a mut W, +} +impl<'a> _ODR8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR7W<'a> { + w: &'a mut W, +} +impl<'a> _ODR7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR6W<'a> { + w: &'a mut W, +} +impl<'a> _ODR6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR5W<'a> { + w: &'a mut W, +} +impl<'a> _ODR5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR4W<'a> { + w: &'a mut W, +} +impl<'a> _ODR4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR3W<'a> { + w: &'a mut W, +} +impl<'a> _ODR3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR2W<'a> { + w: &'a mut W, +} +impl<'a> _ODR2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR1W<'a> { + w: &'a mut W, +} +impl<'a> _ODR1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODR0W<'a> { + w: &'a mut W, +} +impl<'a> _ODR0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&self) -> ODR15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR15R { bits } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&self) -> ODR14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR14R { bits } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&self) -> ODR13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR13R { bits } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&self) -> ODR12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR12R { bits } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&self) -> ODR11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR11R { bits } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&self) -> ODR10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR10R { bits } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&self) -> ODR9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR9R { bits } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&self) -> ODR8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR8R { bits } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&self) -> ODR7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR7R { bits } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&self) -> ODR6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR6R { bits } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&self) -> ODR5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR5R { bits } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&self) -> ODR4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR4R { bits } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&self) -> ODR3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR3R { bits } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&self) -> ODR2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR2R { bits } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&self) -> ODR1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR1R { bits } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&self) -> ODR0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port output data (y = 0..15)"] + #[inline] + pub fn odr15(&mut self) -> _ODR15W { + _ODR15W { w: self } + } + #[doc = "Bit 14 - Port output data (y = 0..15)"] + #[inline] + pub fn odr14(&mut self) -> _ODR14W { + _ODR14W { w: self } + } + #[doc = "Bit 13 - Port output data (y = 0..15)"] + #[inline] + pub fn odr13(&mut self) -> _ODR13W { + _ODR13W { w: self } + } + #[doc = "Bit 12 - Port output data (y = 0..15)"] + #[inline] + pub fn odr12(&mut self) -> _ODR12W { + _ODR12W { w: self } + } + #[doc = "Bit 11 - Port output data (y = 0..15)"] + #[inline] + pub fn odr11(&mut self) -> _ODR11W { + _ODR11W { w: self } + } + #[doc = "Bit 10 - Port output data (y = 0..15)"] + #[inline] + pub fn odr10(&mut self) -> _ODR10W { + _ODR10W { w: self } + } + #[doc = "Bit 9 - Port output data (y = 0..15)"] + #[inline] + pub fn odr9(&mut self) -> _ODR9W { + _ODR9W { w: self } + } + #[doc = "Bit 8 - Port output data (y = 0..15)"] + #[inline] + pub fn odr8(&mut self) -> _ODR8W { + _ODR8W { w: self } + } + #[doc = "Bit 7 - Port output data (y = 0..15)"] + #[inline] + pub fn odr7(&mut self) -> _ODR7W { + _ODR7W { w: self } + } + #[doc = "Bit 6 - Port output data (y = 0..15)"] + #[inline] + pub fn odr6(&mut self) -> _ODR6W { + _ODR6W { w: self } + } + #[doc = "Bit 5 - Port output data (y = 0..15)"] + #[inline] + pub fn odr5(&mut self) -> _ODR5W { + _ODR5W { w: self } + } + #[doc = "Bit 4 - Port output data (y = 0..15)"] + #[inline] + pub fn odr4(&mut self) -> _ODR4W { + _ODR4W { w: self } + } + #[doc = "Bit 3 - Port output data (y = 0..15)"] + #[inline] + pub fn odr3(&mut self) -> _ODR3W { + _ODR3W { w: self } + } + #[doc = "Bit 2 - Port output data (y = 0..15)"] + #[inline] + pub fn odr2(&mut self) -> _ODR2W { + _ODR2W { w: self } + } + #[doc = "Bit 1 - Port output data (y = 0..15)"] + #[inline] + pub fn odr1(&mut self) -> _ODR1W { + _ODR1W { w: self } + } + #[doc = "Bit 0 - Port output data (y = 0..15)"] + #[inline] + pub fn odr0(&mut self) -> _ODR0W { + _ODR0W { w: self } + } +} diff --git a/src/gpioh/ospeedr/mod.rs b/src/gpioh/ospeedr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6502d202dd0308244f74bb245ba1e846dca73c2e --- /dev/null +++ b/src/gpioh/ospeedr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OSPEEDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR15R { + bits: u8, +} +impl OSPEEDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR14R { + bits: u8, +} +impl OSPEEDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR13R { + bits: u8, +} +impl OSPEEDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR12R { + bits: u8, +} +impl OSPEEDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR11R { + bits: u8, +} +impl OSPEEDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR10R { + bits: u8, +} +impl OSPEEDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR9R { + bits: u8, +} +impl OSPEEDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR8R { + bits: u8, +} +impl OSPEEDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR7R { + bits: u8, +} +impl OSPEEDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR6R { + bits: u8, +} +impl OSPEEDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR5R { + bits: u8, +} +impl OSPEEDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR4R { + bits: u8, +} +impl OSPEEDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR3R { + bits: u8, +} +impl OSPEEDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR2R { + bits: u8, +} +impl OSPEEDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR1R { + bits: u8, +} +impl OSPEEDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OSPEEDR0R { + bits: u8, +} +impl OSPEEDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR15W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR14W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR13W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR12W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR11W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR10W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR9W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR8W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR7W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR6W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR5W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR4W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR3W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR2W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR1W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSPEEDR0W<'a> { + w: &'a mut W, +} +impl<'a> _OSPEEDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&self) -> OSPEEDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&self) -> OSPEEDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&self) -> OSPEEDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&self) -> OSPEEDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&self) -> OSPEEDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&self) -> OSPEEDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&self) -> OSPEEDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&self) -> OSPEEDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&self) -> OSPEEDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&self) -> OSPEEDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&self) -> OSPEEDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&self) -> OSPEEDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&self) -> OSPEEDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&self) -> OSPEEDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&self) -> OSPEEDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&self) -> OSPEEDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSPEEDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr15(&mut self) -> _OSPEEDR15W { + _OSPEEDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr14(&mut self) -> _OSPEEDR14W { + _OSPEEDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr13(&mut self) -> _OSPEEDR13W { + _OSPEEDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr12(&mut self) -> _OSPEEDR12W { + _OSPEEDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr11(&mut self) -> _OSPEEDR11W { + _OSPEEDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr10(&mut self) -> _OSPEEDR10W { + _OSPEEDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr9(&mut self) -> _OSPEEDR9W { + _OSPEEDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr8(&mut self) -> _OSPEEDR8W { + _OSPEEDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr7(&mut self) -> _OSPEEDR7W { + _OSPEEDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr6(&mut self) -> _OSPEEDR6W { + _OSPEEDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr5(&mut self) -> _OSPEEDR5W { + _OSPEEDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr4(&mut self) -> _OSPEEDR4W { + _OSPEEDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr3(&mut self) -> _OSPEEDR3W { + _OSPEEDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr2(&mut self) -> _OSPEEDR2W { + _OSPEEDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr1(&mut self) -> _OSPEEDR1W { + _OSPEEDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ospeedr0(&mut self) -> _OSPEEDR0W { + _OSPEEDR0W { w: self } + } +} diff --git a/src/gpioh/otyper/mod.rs b/src/gpioh/otyper/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b5cd09d505177afbbc62399488c69b7fad6598b --- /dev/null +++ b/src/gpioh/otyper/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OTYPER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OT15R { + bits: bool, +} +impl OT15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT14R { + bits: bool, +} +impl OT14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT13R { + bits: bool, +} +impl OT13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT12R { + bits: bool, +} +impl OT12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT11R { + bits: bool, +} +impl OT11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT10R { + bits: bool, +} +impl OT10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT9R { + bits: bool, +} +impl OT9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT8R { + bits: bool, +} +impl OT8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT7R { + bits: bool, +} +impl OT7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT6R { + bits: bool, +} +impl OT6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT5R { + bits: bool, +} +impl OT5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT4R { + bits: bool, +} +impl OT4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT3R { + bits: bool, +} +impl OT3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT2R { + bits: bool, +} +impl OT2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT1R { + bits: bool, +} +impl OT1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OT0R { + bits: bool, +} +impl OT0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OT15W<'a> { + w: &'a mut W, +} +impl<'a> _OT15W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT14W<'a> { + w: &'a mut W, +} +impl<'a> _OT14W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT13W<'a> { + w: &'a mut W, +} +impl<'a> _OT13W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT12W<'a> { + w: &'a mut W, +} +impl<'a> _OT12W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT11W<'a> { + w: &'a mut W, +} +impl<'a> _OT11W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT10W<'a> { + w: &'a mut W, +} +impl<'a> _OT10W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT9W<'a> { + w: &'a mut W, +} +impl<'a> _OT9W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT8W<'a> { + w: &'a mut W, +} +impl<'a> _OT8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT7W<'a> { + w: &'a mut W, +} +impl<'a> _OT7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT6W<'a> { + w: &'a mut W, +} +impl<'a> _OT6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT5W<'a> { + w: &'a mut W, +} +impl<'a> _OT5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT4W<'a> { + w: &'a mut W, +} +impl<'a> _OT4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT3W<'a> { + w: &'a mut W, +} +impl<'a> _OT3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT2W<'a> { + w: &'a mut W, +} +impl<'a> _OT2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT1W<'a> { + w: &'a mut W, +} +impl<'a> _OT1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OT0W<'a> { + w: &'a mut W, +} +impl<'a> _OT0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&self) -> OT15R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT15R { bits } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&self) -> OT14R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT14R { bits } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&self) -> OT13R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT13R { bits } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&self) -> OT12R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT12R { bits } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&self) -> OT11R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT11R { bits } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&self) -> OT10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT10R { bits } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&self) -> OT9R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT9R { bits } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&self) -> OT8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT8R { bits } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&self) -> OT7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT7R { bits } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&self) -> OT6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT6R { bits } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&self) -> OT5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT5R { bits } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&self) -> OT4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT4R { bits } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&self) -> OT3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT3R { bits } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&self) -> OT2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT2R { bits } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&self) -> OT1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT1R { bits } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&self) -> OT0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OT0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot15(&mut self) -> _OT15W { + _OT15W { w: self } + } + #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot14(&mut self) -> _OT14W { + _OT14W { w: self } + } + #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot13(&mut self) -> _OT13W { + _OT13W { w: self } + } + #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot12(&mut self) -> _OT12W { + _OT12W { w: self } + } + #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot11(&mut self) -> _OT11W { + _OT11W { w: self } + } + #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot10(&mut self) -> _OT10W { + _OT10W { w: self } + } + #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot9(&mut self) -> _OT9W { + _OT9W { w: self } + } + #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot8(&mut self) -> _OT8W { + _OT8W { w: self } + } + #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot7(&mut self) -> _OT7W { + _OT7W { w: self } + } + #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot6(&mut self) -> _OT6W { + _OT6W { w: self } + } + #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot5(&mut self) -> _OT5W { + _OT5W { w: self } + } + #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot4(&mut self) -> _OT4W { + _OT4W { w: self } + } + #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot3(&mut self) -> _OT3W { + _OT3W { w: self } + } + #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot2(&mut self) -> _OT2W { + _OT2W { w: self } + } + #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot1(&mut self) -> _OT1W { + _OT1W { w: self } + } + #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn ot0(&mut self) -> _OT0W { + _OT0W { w: self } + } +} diff --git a/src/gpioh/pupdr/mod.rs b/src/gpioh/pupdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..13cdd5d4c138ae7ce4e85fec74b62b690978fa3b --- /dev/null +++ b/src/gpioh/pupdr/mod.rs @@ -0,0 +1,720 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PUPDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PUPDR15R { + bits: u8, +} +impl PUPDR15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR14R { + bits: u8, +} +impl PUPDR14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR13R { + bits: u8, +} +impl PUPDR13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR12R { + bits: u8, +} +impl PUPDR12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR11R { + bits: u8, +} +impl PUPDR11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR10R { + bits: u8, +} +impl PUPDR10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR9R { + bits: u8, +} +impl PUPDR9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR8R { + bits: u8, +} +impl PUPDR8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR7R { + bits: u8, +} +impl PUPDR7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR6R { + bits: u8, +} +impl PUPDR6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR5R { + bits: u8, +} +impl PUPDR5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR4R { + bits: u8, +} +impl PUPDR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR3R { + bits: u8, +} +impl PUPDR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR2R { + bits: u8, +} +impl PUPDR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR1R { + bits: u8, +} +impl PUPDR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PUPDR0R { + bits: u8, +} +impl PUPDR0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PUPDR15W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR14W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR13W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR12W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR11W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR10W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR9W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR8W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR7W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR6W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR5W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR4W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR3W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR2W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR1W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PUPDR0W<'a> { + w: &'a mut W, +} +impl<'a> _PUPDR0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&self) -> PUPDR15R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR15R { bits } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&self) -> PUPDR14R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR14R { bits } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&self) -> PUPDR13R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR13R { bits } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&self) -> PUPDR12R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR12R { bits } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&self) -> PUPDR11R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR11R { bits } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&self) -> PUPDR10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR10R { bits } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&self) -> PUPDR9R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR9R { bits } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&self) -> PUPDR8R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR8R { bits } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&self) -> PUPDR7R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR7R { bits } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&self) -> PUPDR6R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR6R { bits } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&self) -> PUPDR5R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR5R { bits } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&self) -> PUPDR4R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR4R { bits } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&self) -> PUPDR3R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR3R { bits } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&self) -> PUPDR2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR2R { bits } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&self) -> PUPDR1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR1R { bits } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&self) -> PUPDR0R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PUPDR0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr15(&mut self) -> _PUPDR15W { + _PUPDR15W { w: self } + } + #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr14(&mut self) -> _PUPDR14W { + _PUPDR14W { w: self } + } + #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr13(&mut self) -> _PUPDR13W { + _PUPDR13W { w: self } + } + #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr12(&mut self) -> _PUPDR12W { + _PUPDR12W { w: self } + } + #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr11(&mut self) -> _PUPDR11W { + _PUPDR11W { w: self } + } + #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr10(&mut self) -> _PUPDR10W { + _PUPDR10W { w: self } + } + #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr9(&mut self) -> _PUPDR9W { + _PUPDR9W { w: self } + } + #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr8(&mut self) -> _PUPDR8W { + _PUPDR8W { w: self } + } + #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr7(&mut self) -> _PUPDR7W { + _PUPDR7W { w: self } + } + #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr6(&mut self) -> _PUPDR6W { + _PUPDR6W { w: self } + } + #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr5(&mut self) -> _PUPDR5W { + _PUPDR5W { w: self } + } + #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr4(&mut self) -> _PUPDR4W { + _PUPDR4W { w: self } + } + #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr3(&mut self) -> _PUPDR3W { + _PUPDR3W { w: self } + } + #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr2(&mut self) -> _PUPDR2W { + _PUPDR2W { w: self } + } + #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr1(&mut self) -> _PUPDR1W { + _PUPDR1W { w: self } + } + #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] + #[inline] + pub fn pupdr0(&mut self) -> _PUPDR0W { + _PUPDR0W { w: self } + } +} diff --git a/src/i2c3/ccr/mod.rs b/src/i2c3/ccr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c5dc0b05afba19ecd899d372455e0f9d4e488f42 --- /dev/null +++ b/src/i2c3/ccr/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct F_SR { + bits: bool, +} +impl F_SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DUTYR { + bits: bool, +} +impl DUTYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCRR { + bits: u16, +} +impl CCRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _F_SW<'a> { + w: &'a mut W, +} +impl<'a> _F_SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DUTYW<'a> { + w: &'a mut W, +} +impl<'a> _DUTYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCRW<'a> { + w: &'a mut W, +} +impl<'a> _CCRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - I2C master mode selection"] + #[inline] + pub fn f_s(&self) -> F_SR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + F_SR { bits } + } + #[doc = "Bit 14 - Fast mode duty cycle"] + #[inline] + pub fn duty(&self) -> DUTYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DUTYR { bits } + } + #[doc = "Bits 0:11 - Clock control register in Fast/Standard mode (Master mode)"] + #[inline] + pub fn ccr(&self) -> CCRR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - I2C master mode selection"] + #[inline] + pub fn f_s(&mut self) -> _F_SW { + _F_SW { w: self } + } + #[doc = "Bit 14 - Fast mode duty cycle"] + #[inline] + pub fn duty(&mut self) -> _DUTYW { + _DUTYW { w: self } + } + #[doc = "Bits 0:11 - Clock control register in Fast/Standard mode (Master mode)"] + #[inline] + pub fn ccr(&mut self) -> _CCRW { + _CCRW { w: self } + } +} diff --git a/src/i2c3/cr1/mod.rs b/src/i2c3/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a9c045123394667b881ddb9b281033f72dda152b --- /dev/null +++ b/src/i2c3/cr1/mod.rs @@ -0,0 +1,890 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SWRSTR { + bits: bool, +} +impl SWRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALERTR { + bits: bool, +} +impl ALERTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PECR { + bits: bool, +} +impl PECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct POSR { + bits: bool, +} +impl POSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPR { + bits: bool, +} +impl STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STARTR { + bits: bool, +} +impl STARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NOSTRETCHR { + bits: bool, +} +impl NOSTRETCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENGCR { + bits: bool, +} +impl ENGCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENPECR { + bits: bool, +} +impl ENPECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENARPR { + bits: bool, +} +impl ENARPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBTYPER { + bits: bool, +} +impl SMBTYPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBUSR { + bits: bool, +} +impl SMBUSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PER { + bits: bool, +} +impl PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SWRSTW<'a> { + w: &'a mut W, +} +impl<'a> _SWRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALERTW<'a> { + w: &'a mut W, +} +impl<'a> _ALERTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PECW<'a> { + w: &'a mut W, +} +impl<'a> _PECW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _POSW<'a> { + w: &'a mut W, +} +impl<'a> _POSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STOPW<'a> { + w: &'a mut W, +} +impl<'a> _STOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STARTW<'a> { + w: &'a mut W, +} +impl<'a> _STARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NOSTRETCHW<'a> { + w: &'a mut W, +} +impl<'a> _NOSTRETCHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENGCW<'a> { + w: &'a mut W, +} +impl<'a> _ENGCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENPECW<'a> { + w: &'a mut W, +} +impl<'a> _ENPECW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENARPW<'a> { + w: &'a mut W, +} +impl<'a> _ENARPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMBTYPEW<'a> { + w: &'a mut W, +} +impl<'a> _SMBTYPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMBUSW<'a> { + w: &'a mut W, +} +impl<'a> _SMBUSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PEW<'a> { + w: &'a mut W, +} +impl<'a> _PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Software reset"] + #[inline] + pub fn swrst(&self) -> SWRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWRSTR { bits } + } + #[doc = "Bit 13 - SMBus alert"] + #[inline] + pub fn alert(&self) -> ALERTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALERTR { bits } + } + #[doc = "Bit 12 - Packet error checking"] + #[inline] + pub fn pec(&self) -> PECR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PECR { bits } + } + #[doc = "Bit 11 - Acknowledge/PEC Position (for data reception)"] + #[inline] + pub fn pos(&self) -> POSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + POSR { bits } + } + #[doc = "Bit 10 - Acknowledge enable"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 9 - Stop generation"] + #[inline] + pub fn stop(&self) -> STOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STOPR { bits } + } + #[doc = "Bit 8 - Start generation"] + #[inline] + pub fn start(&self) -> STARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STARTR { bits } + } + #[doc = "Bit 7 - Clock stretching disable (Slave mode)"] + #[inline] + pub fn nostretch(&self) -> NOSTRETCHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NOSTRETCHR { bits } + } + #[doc = "Bit 6 - General call enable"] + #[inline] + pub fn engc(&self) -> ENGCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENGCR { bits } + } + #[doc = "Bit 5 - PEC enable"] + #[inline] + pub fn enpec(&self) -> ENPECR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENPECR { bits } + } + #[doc = "Bit 4 - ARP enable"] + #[inline] + pub fn enarp(&self) -> ENARPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENARPR { bits } + } + #[doc = "Bit 3 - SMBus type"] + #[inline] + pub fn smbtype(&self) -> SMBTYPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBTYPER { bits } + } + #[doc = "Bit 1 - SMBus mode"] + #[inline] + pub fn smbus(&self) -> SMBUSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBUSR { bits } + } + #[doc = "Bit 0 - Peripheral enable"] + #[inline] + pub fn pe(&self) -> PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Software reset"] + #[inline] + pub fn swrst(&mut self) -> _SWRSTW { + _SWRSTW { w: self } + } + #[doc = "Bit 13 - SMBus alert"] + #[inline] + pub fn alert(&mut self) -> _ALERTW { + _ALERTW { w: self } + } + #[doc = "Bit 12 - Packet error checking"] + #[inline] + pub fn pec(&mut self) -> _PECW { + _PECW { w: self } + } + #[doc = "Bit 11 - Acknowledge/PEC Position (for data reception)"] + #[inline] + pub fn pos(&mut self) -> _POSW { + _POSW { w: self } + } + #[doc = "Bit 10 - Acknowledge enable"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 9 - Stop generation"] + #[inline] + pub fn stop(&mut self) -> _STOPW { + _STOPW { w: self } + } + #[doc = "Bit 8 - Start generation"] + #[inline] + pub fn start(&mut self) -> _STARTW { + _STARTW { w: self } + } + #[doc = "Bit 7 - Clock stretching disable (Slave mode)"] + #[inline] + pub fn nostretch(&mut self) -> _NOSTRETCHW { + _NOSTRETCHW { w: self } + } + #[doc = "Bit 6 - General call enable"] + #[inline] + pub fn engc(&mut self) -> _ENGCW { + _ENGCW { w: self } + } + #[doc = "Bit 5 - PEC enable"] + #[inline] + pub fn enpec(&mut self) -> _ENPECW { + _ENPECW { w: self } + } + #[doc = "Bit 4 - ARP enable"] + #[inline] + pub fn enarp(&mut self) -> _ENARPW { + _ENARPW { w: self } + } + #[doc = "Bit 3 - SMBus type"] + #[inline] + pub fn smbtype(&mut self) -> _SMBTYPEW { + _SMBTYPEW { w: self } + } + #[doc = "Bit 1 - SMBus mode"] + #[inline] + pub fn smbus(&mut self) -> _SMBUSW { + _SMBUSW { w: self } + } + #[doc = "Bit 0 - Peripheral enable"] + #[inline] + pub fn pe(&mut self) -> _PEW { + _PEW { w: self } + } +} diff --git a/src/i2c3/cr2/mod.rs b/src/i2c3/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..142ef71d57123c4076cbfcf4b09acb09fadae0bb --- /dev/null +++ b/src/i2c3/cr2/mod.rs @@ -0,0 +1,400 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LASTR { + bits: bool, +} +impl LASTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAENR { + bits: bool, +} +impl DMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITBUFENR { + bits: bool, +} +impl ITBUFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITEVTENR { + bits: bool, +} +impl ITEVTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITERRENR { + bits: bool, +} +impl ITERRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FREQR { + bits: u8, +} +impl FREQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _LASTW<'a> { + w: &'a mut W, +} +impl<'a> _LASTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITBUFENW<'a> { + w: &'a mut W, +} +impl<'a> _ITBUFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITEVTENW<'a> { + w: &'a mut W, +} +impl<'a> _ITEVTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITERRENW<'a> { + w: &'a mut W, +} +impl<'a> _ITERRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FREQW<'a> { + w: &'a mut W, +} +impl<'a> _FREQW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - DMA last transfer"] + #[inline] + pub fn last(&self) -> LASTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LASTR { bits } + } + #[doc = "Bit 11 - DMA requests enable"] + #[inline] + pub fn dmaen(&self) -> DMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAENR { bits } + } + #[doc = "Bit 10 - Buffer interrupt enable"] + #[inline] + pub fn itbufen(&self) -> ITBUFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITBUFENR { bits } + } + #[doc = "Bit 9 - Event interrupt enable"] + #[inline] + pub fn itevten(&self) -> ITEVTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITEVTENR { bits } + } + #[doc = "Bit 8 - Error interrupt enable"] + #[inline] + pub fn iterren(&self) -> ITERRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITERRENR { bits } + } + #[doc = "Bits 0:5 - Peripheral clock frequency"] + #[inline] + pub fn freq(&self) -> FREQR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FREQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - DMA last transfer"] + #[inline] + pub fn last(&mut self) -> _LASTW { + _LASTW { w: self } + } + #[doc = "Bit 11 - DMA requests enable"] + #[inline] + pub fn dmaen(&mut self) -> _DMAENW { + _DMAENW { w: self } + } + #[doc = "Bit 10 - Buffer interrupt enable"] + #[inline] + pub fn itbufen(&mut self) -> _ITBUFENW { + _ITBUFENW { w: self } + } + #[doc = "Bit 9 - Event interrupt enable"] + #[inline] + pub fn itevten(&mut self) -> _ITEVTENW { + _ITEVTENW { w: self } + } + #[doc = "Bit 8 - Error interrupt enable"] + #[inline] + pub fn iterren(&mut self) -> _ITERRENW { + _ITERRENW { w: self } + } + #[doc = "Bits 0:5 - Peripheral clock frequency"] + #[inline] + pub fn freq(&mut self) -> _FREQW { + _FREQW { w: self } + } +} diff --git a/src/i2c3/dr/mod.rs b/src/i2c3/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bfc37762cca7c0b49d58ae378859fcf7c2ad4107 --- /dev/null +++ b/src/i2c3/dr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DRR { + bits: u8, +} +impl DRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DRW<'a> { + w: &'a mut W, +} +impl<'a> _DRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - 8-bit data register"] + #[inline] + pub fn dr(&self) -> DRR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - 8-bit data register"] + #[inline] + pub fn dr(&mut self) -> _DRW { + _DRW { w: self } + } +} diff --git a/src/i2c3/mod.rs b/src/i2c3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b836fa1518045c598f9bc1963878dacf91f7759f --- /dev/null +++ b/src/i2c3/mod.rs @@ -0,0 +1,76 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Control register 1"] + pub cr1: CR1, + #[doc = "0x04 - Control register 2"] + pub cr2: CR2, + #[doc = "0x08 - Own address register 1"] + pub oar1: OAR1, + #[doc = "0x0c - Own address register 2"] + pub oar2: OAR2, + #[doc = "0x10 - Data register"] + pub dr: DR, + #[doc = "0x14 - Status register 1"] + pub sr1: SR1, + #[doc = "0x18 - Status register 2"] + pub sr2: SR2, + #[doc = "0x1c - Clock control register"] + pub ccr: CCR, + #[doc = "0x20 - TRISE register"] + pub trise: TRISE, +} +#[doc = "Control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 1"] +pub mod cr1; +#[doc = "Control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 2"] +pub mod cr2; +#[doc = "Own address register 1"] +pub struct OAR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Own address register 1"] +pub mod oar1; +#[doc = "Own address register 2"] +pub struct OAR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Own address register 2"] +pub mod oar2; +#[doc = "Data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Data register"] +pub mod dr; +#[doc = "Status register 1"] +pub struct SR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register 1"] +pub mod sr1; +#[doc = "Status register 2"] +pub struct SR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register 2"] +pub mod sr2; +#[doc = "Clock control register"] +pub struct CCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Clock control register"] +pub mod ccr; +#[doc = "TRISE register"] +pub struct TRISE { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "TRISE register"] +pub mod trise; diff --git a/src/i2c3/oar1/mod.rs b/src/i2c3/oar1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aad118635ce5f515faf451db3e2aa7ffdcfd90a5 --- /dev/null +++ b/src/i2c3/oar1/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OAR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ADDMODER { + bits: bool, +} +impl ADDMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADD10R { + bits: u8, +} +impl ADD10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADD7R { + bits: u8, +} +impl ADD7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADD0R { + bits: bool, +} +impl ADD0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ADDMODEW<'a> { + w: &'a mut W, +} +impl<'a> _ADDMODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADD10W<'a> { + w: &'a mut W, +} +impl<'a> _ADD10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADD7W<'a> { + w: &'a mut W, +} +impl<'a> _ADD7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADD0W<'a> { + w: &'a mut W, +} +impl<'a> _ADD0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Addressing mode (slave mode)"] + #[inline] + pub fn addmode(&self) -> ADDMODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADDMODER { bits } + } + #[doc = "Bits 8:9 - Interface address"] + #[inline] + pub fn add10(&self) -> ADD10R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADD10R { bits } + } + #[doc = "Bits 1:7 - Interface address"] + #[inline] + pub fn add7(&self) -> ADD7R { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADD7R { bits } + } + #[doc = "Bit 0 - Interface address"] + #[inline] + pub fn add0(&self) -> ADD0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADD0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Addressing mode (slave mode)"] + #[inline] + pub fn addmode(&mut self) -> _ADDMODEW { + _ADDMODEW { w: self } + } + #[doc = "Bits 8:9 - Interface address"] + #[inline] + pub fn add10(&mut self) -> _ADD10W { + _ADD10W { w: self } + } + #[doc = "Bits 1:7 - Interface address"] + #[inline] + pub fn add7(&mut self) -> _ADD7W { + _ADD7W { w: self } + } + #[doc = "Bit 0 - Interface address"] + #[inline] + pub fn add0(&mut self) -> _ADD0W { + _ADD0W { w: self } + } +} diff --git a/src/i2c3/oar2/mod.rs b/src/i2c3/oar2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..248cdfa5102a6b609e1b3748662d256928923c4e --- /dev/null +++ b/src/i2c3/oar2/mod.rs @@ -0,0 +1,164 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OAR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ADD2R { + bits: u8, +} +impl ADD2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ENDUALR { + bits: bool, +} +impl ENDUALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ADD2W<'a> { + w: &'a mut W, +} +impl<'a> _ADD2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENDUALW<'a> { + w: &'a mut W, +} +impl<'a> _ENDUALW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 1:7 - Interface address"] + #[inline] + pub fn add2(&self) -> ADD2R { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADD2R { bits } + } + #[doc = "Bit 0 - Dual addressing mode enable"] + #[inline] + pub fn endual(&self) -> ENDUALR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENDUALR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 1:7 - Interface address"] + #[inline] + pub fn add2(&mut self) -> _ADD2W { + _ADD2W { w: self } + } + #[doc = "Bit 0 - Dual addressing mode enable"] + #[inline] + pub fn endual(&mut self) -> _ENDUALW { + _ENDUALW { w: self } + } +} diff --git a/src/i2c3/sr1/mod.rs b/src/i2c3/sr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b86dda37fc6ad580fa0ccf6c01015fdc3ea4f2b7 --- /dev/null +++ b/src/i2c3/sr1/mod.rs @@ -0,0 +1,694 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SMBALERTR { + bits: bool, +} +impl SMBALERTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMEOUTR { + bits: bool, +} +impl TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PECERRR { + bits: bool, +} +impl PECERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRR { + bits: bool, +} +impl OVRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AFR { + bits: bool, +} +impl AFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARLOR { + bits: bool, +} +impl ARLOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BERRR { + bits: bool, +} +impl BERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXER { + bits: bool, +} +impl TXER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNER { + bits: bool, +} +impl RXNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPFR { + bits: bool, +} +impl STOPFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADD10R { + bits: bool, +} +impl ADD10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BTFR { + bits: bool, +} +impl BTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADDRR { + bits: bool, +} +impl ADDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SBR { + bits: bool, +} +impl SBR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SMBALERTW<'a> { + w: &'a mut W, +} +impl<'a> _SMBALERTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMEOUTW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PECERRW<'a> { + w: &'a mut W, +} +impl<'a> _PECERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRW<'a> { + w: &'a mut W, +} +impl<'a> _OVRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFW<'a> { + w: &'a mut W, +} +impl<'a> _AFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARLOW<'a> { + w: &'a mut W, +} +impl<'a> _ARLOW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BERRW<'a> { + w: &'a mut W, +} +impl<'a> _BERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - SMBus alert"] + #[inline] + pub fn smbalert(&self) -> SMBALERTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBALERTR { bits } + } + #[doc = "Bit 14 - Timeout or Tlow error"] + #[inline] + pub fn timeout(&self) -> TIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIMEOUTR { bits } + } + #[doc = "Bit 12 - PEC Error in reception"] + #[inline] + pub fn pecerr(&self) -> PECERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PECERRR { bits } + } + #[doc = "Bit 11 - Overrun/Underrun"] + #[inline] + pub fn ovr(&self) -> OVRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRR { bits } + } + #[doc = "Bit 10 - Acknowledge failure"] + #[inline] + pub fn af(&self) -> AFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AFR { bits } + } + #[doc = "Bit 9 - Arbitration lost (master mode)"] + #[inline] + pub fn arlo(&self) -> ARLOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARLOR { bits } + } + #[doc = "Bit 8 - Bus error"] + #[inline] + pub fn berr(&self) -> BERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BERRR { bits } + } + #[doc = "Bit 7 - Data register empty (transmitters)"] + #[inline] + pub fn tx_e(&self) -> TXER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXER { bits } + } + #[doc = "Bit 6 - Data register not empty (receivers)"] + #[inline] + pub fn rx_ne(&self) -> RXNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNER { bits } + } + #[doc = "Bit 4 - Stop detection (slave mode)"] + #[inline] + pub fn stopf(&self) -> STOPFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STOPFR { bits } + } + #[doc = "Bit 3 - 10-bit header sent (Master mode)"] + #[inline] + pub fn add10(&self) -> ADD10R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADD10R { bits } + } + #[doc = "Bit 2 - Byte transfer finished"] + #[inline] + pub fn btf(&self) -> BTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BTFR { bits } + } + #[doc = "Bit 1 - Address sent (master mode)/matched (slave mode)"] + #[inline] + pub fn addr(&self) -> ADDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADDRR { bits } + } + #[doc = "Bit 0 - Start bit (Master mode)"] + #[inline] + pub fn sb(&self) -> SBR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SBR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - SMBus alert"] + #[inline] + pub fn smbalert(&mut self) -> _SMBALERTW { + _SMBALERTW { w: self } + } + #[doc = "Bit 14 - Timeout or Tlow error"] + #[inline] + pub fn timeout(&mut self) -> _TIMEOUTW { + _TIMEOUTW { w: self } + } + #[doc = "Bit 12 - PEC Error in reception"] + #[inline] + pub fn pecerr(&mut self) -> _PECERRW { + _PECERRW { w: self } + } + #[doc = "Bit 11 - Overrun/Underrun"] + #[inline] + pub fn ovr(&mut self) -> _OVRW { + _OVRW { w: self } + } + #[doc = "Bit 10 - Acknowledge failure"] + #[inline] + pub fn af(&mut self) -> _AFW { + _AFW { w: self } + } + #[doc = "Bit 9 - Arbitration lost (master mode)"] + #[inline] + pub fn arlo(&mut self) -> _ARLOW { + _ARLOW { w: self } + } + #[doc = "Bit 8 - Bus error"] + #[inline] + pub fn berr(&mut self) -> _BERRW { + _BERRW { w: self } + } +} diff --git a/src/i2c3/sr2/mod.rs b/src/i2c3/sr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..239ecaac31be2dffa306188be6a40cb420662cfe --- /dev/null +++ b/src/i2c3/sr2/mod.rs @@ -0,0 +1,258 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::SR2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct PECR { + bits: u8, +} +impl PECR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DUALFR { + bits: bool, +} +impl DUALFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBHOSTR { + bits: bool, +} +impl SMBHOSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMBDEFAULTR { + bits: bool, +} +impl SMBDEFAULTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GENCALLR { + bits: bool, +} +impl GENCALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRAR { + bits: bool, +} +impl TRAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BUSYR { + bits: bool, +} +impl BUSYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MSLR { + bits: bool, +} +impl MSLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - acket error checking register"] + #[inline] + pub fn pec(&self) -> PECR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PECR { bits } + } + #[doc = "Bit 7 - Dual flag (Slave mode)"] + #[inline] + pub fn dualf(&self) -> DUALFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DUALFR { bits } + } + #[doc = "Bit 6 - SMBus host header (Slave mode)"] + #[inline] + pub fn smbhost(&self) -> SMBHOSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBHOSTR { bits } + } + #[doc = "Bit 5 - SMBus device default address (Slave mode)"] + #[inline] + pub fn smbdefault(&self) -> SMBDEFAULTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMBDEFAULTR { bits } + } + #[doc = "Bit 4 - General call address (Slave mode)"] + #[inline] + pub fn gencall(&self) -> GENCALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GENCALLR { bits } + } + #[doc = "Bit 2 - Transmitter/receiver"] + #[inline] + pub fn tra(&self) -> TRAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TRAR { bits } + } + #[doc = "Bit 1 - Bus busy"] + #[inline] + pub fn busy(&self) -> BUSYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BUSYR { bits } + } + #[doc = "Bit 0 - Master/slave"] + #[inline] + pub fn msl(&self) -> MSLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSLR { bits } + } +} diff --git a/src/i2c3/trise/mod.rs b/src/i2c3/trise/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f0e1507a5c9170c388435b6daa5d07b21c3f294e --- /dev/null +++ b/src/i2c3/trise/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TRISE { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TRISER { + bits: u8, +} +impl TRISER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TRISEW<'a> { + w: &'a mut W, +} +impl<'a> _TRISEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:5 - Maximum rise time in Fast/Standard mode (Master mode)"] + #[inline] + pub fn trise(&self) -> TRISER { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRISER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:5 - Maximum rise time in Fast/Standard mode (Master mode)"] + #[inline] + pub fn trise(&mut self) -> _TRISEW { + _TRISEW { w: self } + } +} diff --git a/src/i2s2ext/cr1/mod.rs b/src/i2s2ext/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..010aa34f7eb7da93cdb84b2eddc8d6e3c8405304 --- /dev/null +++ b/src/i2s2ext/cr1/mod.rs @@ -0,0 +1,872 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BIDIMODER { + bits: bool, +} +impl BIDIMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BIDIOER { + bits: bool, +} +impl BIDIOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCENR { + bits: bool, +} +impl CRCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCNEXTR { + bits: bool, +} +impl CRCNEXTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFFR { + bits: bool, +} +impl DFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXONLYR { + bits: bool, +} +impl RXONLYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SSMR { + bits: bool, +} +impl SSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SSIR { + bits: bool, +} +impl SSIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSBFIRSTR { + bits: bool, +} +impl LSBFIRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPER { + bits: bool, +} +impl SPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BRR { + bits: u8, +} +impl BRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSTRR { + bits: bool, +} +impl MSTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CPOLR { + bits: bool, +} +impl CPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CPHAR { + bits: bool, +} +impl CPHAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _BIDIMODEW<'a> { + w: &'a mut W, +} +impl<'a> _BIDIMODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BIDIOEW<'a> { + w: &'a mut W, +} +impl<'a> _BIDIOEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRCENW<'a> { + w: &'a mut W, +} +impl<'a> _CRCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRCNEXTW<'a> { + w: &'a mut W, +} +impl<'a> _CRCNEXTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFFW<'a> { + w: &'a mut W, +} +impl<'a> _DFFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXONLYW<'a> { + w: &'a mut W, +} +impl<'a> _RXONLYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSMW<'a> { + w: &'a mut W, +} +impl<'a> _SSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSIW<'a> { + w: &'a mut W, +} +impl<'a> _SSIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSBFIRSTW<'a> { + w: &'a mut W, +} +impl<'a> _LSBFIRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPEW<'a> { + w: &'a mut W, +} +impl<'a> _SPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BRW<'a> { + w: &'a mut W, +} +impl<'a> _BRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSTRW<'a> { + w: &'a mut W, +} +impl<'a> _MSTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPOLW<'a> { + w: &'a mut W, +} +impl<'a> _CPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPHAW<'a> { + w: &'a mut W, +} +impl<'a> _CPHAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Bidirectional data mode enable"] + #[inline] + pub fn bidimode(&self) -> BIDIMODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BIDIMODER { bits } + } + #[doc = "Bit 14 - Output enable in bidirectional mode"] + #[inline] + pub fn bidioe(&self) -> BIDIOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BIDIOER { bits } + } + #[doc = "Bit 13 - Hardware CRC calculation enable"] + #[inline] + pub fn crcen(&self) -> CRCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCENR { bits } + } + #[doc = "Bit 12 - CRC transfer next"] + #[inline] + pub fn crcnext(&self) -> CRCNEXTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCNEXTR { bits } + } + #[doc = "Bit 11 - Data frame format"] + #[inline] + pub fn dff(&self) -> DFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFFR { bits } + } + #[doc = "Bit 10 - Receive only"] + #[inline] + pub fn rxonly(&self) -> RXONLYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXONLYR { bits } + } + #[doc = "Bit 9 - Software slave management"] + #[inline] + pub fn ssm(&self) -> SSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SSMR { bits } + } + #[doc = "Bit 8 - Internal slave select"] + #[inline] + pub fn ssi(&self) -> SSIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SSIR { bits } + } + #[doc = "Bit 7 - Frame format"] + #[inline] + pub fn lsbfirst(&self) -> LSBFIRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSBFIRSTR { bits } + } + #[doc = "Bit 6 - SPI enable"] + #[inline] + pub fn spe(&self) -> SPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPER { bits } + } + #[doc = "Bits 3:5 - Baud rate control"] + #[inline] + pub fn br(&self) -> BRR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + BRR { bits } + } + #[doc = "Bit 2 - Master selection"] + #[inline] + pub fn mstr(&self) -> MSTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSTRR { bits } + } + #[doc = "Bit 1 - Clock polarity"] + #[inline] + pub fn cpol(&self) -> CPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPOLR { bits } + } + #[doc = "Bit 0 - Clock phase"] + #[inline] + pub fn cpha(&self) -> CPHAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPHAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Bidirectional data mode enable"] + #[inline] + pub fn bidimode(&mut self) -> _BIDIMODEW { + _BIDIMODEW { w: self } + } + #[doc = "Bit 14 - Output enable in bidirectional mode"] + #[inline] + pub fn bidioe(&mut self) -> _BIDIOEW { + _BIDIOEW { w: self } + } + #[doc = "Bit 13 - Hardware CRC calculation enable"] + #[inline] + pub fn crcen(&mut self) -> _CRCENW { + _CRCENW { w: self } + } + #[doc = "Bit 12 - CRC transfer next"] + #[inline] + pub fn crcnext(&mut self) -> _CRCNEXTW { + _CRCNEXTW { w: self } + } + #[doc = "Bit 11 - Data frame format"] + #[inline] + pub fn dff(&mut self) -> _DFFW { + _DFFW { w: self } + } + #[doc = "Bit 10 - Receive only"] + #[inline] + pub fn rxonly(&mut self) -> _RXONLYW { + _RXONLYW { w: self } + } + #[doc = "Bit 9 - Software slave management"] + #[inline] + pub fn ssm(&mut self) -> _SSMW { + _SSMW { w: self } + } + #[doc = "Bit 8 - Internal slave select"] + #[inline] + pub fn ssi(&mut self) -> _SSIW { + _SSIW { w: self } + } + #[doc = "Bit 7 - Frame format"] + #[inline] + pub fn lsbfirst(&mut self) -> _LSBFIRSTW { + _LSBFIRSTW { w: self } + } + #[doc = "Bit 6 - SPI enable"] + #[inline] + pub fn spe(&mut self) -> _SPEW { + _SPEW { w: self } + } + #[doc = "Bits 3:5 - Baud rate control"] + #[inline] + pub fn br(&mut self) -> _BRW { + _BRW { w: self } + } + #[doc = "Bit 2 - Master selection"] + #[inline] + pub fn mstr(&mut self) -> _MSTRW { + _MSTRW { w: self } + } + #[doc = "Bit 1 - Clock polarity"] + #[inline] + pub fn cpol(&mut self) -> _CPOLW { + _CPOLW { w: self } + } + #[doc = "Bit 0 - Clock phase"] + #[inline] + pub fn cpha(&mut self) -> _CPHAW { + _CPHAW { w: self } + } +} diff --git a/src/i2s2ext/cr2/mod.rs b/src/i2s2ext/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5e93e040748be0d539084f4eb80d2a492fa17cc9 --- /dev/null +++ b/src/i2s2ext/cr2/mod.rs @@ -0,0 +1,477 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXEIER { + bits: bool, +} +impl TXEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNEIER { + bits: bool, +} +impl RXNEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ERRIER { + bits: bool, +} +impl ERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRFR { + bits: bool, +} +impl FRFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SSOER { + bits: bool, +} +impl SSOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXDMAENR { + bits: bool, +} +impl TXDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXDMAENR { + bits: bool, +} +impl RXDMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TXEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXNEIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXNEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _ERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRFW<'a> { + w: &'a mut W, +} +impl<'a> _FRFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSOEW<'a> { + w: &'a mut W, +} +impl<'a> _SSOEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _TXDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXDMAENW<'a> { + w: &'a mut W, +} +impl<'a> _RXDMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Tx buffer empty interrupt enable"] + #[inline] + pub fn txeie(&self) -> TXEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXEIER { bits } + } + #[doc = "Bit 6 - RX buffer not empty interrupt enable"] + #[inline] + pub fn rxneie(&self) -> RXNEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNEIER { bits } + } + #[doc = "Bit 5 - Error interrupt enable"] + #[inline] + pub fn errie(&self) -> ERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ERRIER { bits } + } + #[doc = "Bit 4 - Frame format"] + #[inline] + pub fn frf(&self) -> FRFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRFR { bits } + } + #[doc = "Bit 2 - SS output enable"] + #[inline] + pub fn ssoe(&self) -> SSOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SSOER { bits } + } + #[doc = "Bit 1 - Tx buffer DMA enable"] + #[inline] + pub fn txdmaen(&self) -> TXDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXDMAENR { bits } + } + #[doc = "Bit 0 - Rx buffer DMA enable"] + #[inline] + pub fn rxdmaen(&self) -> RXDMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXDMAENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Tx buffer empty interrupt enable"] + #[inline] + pub fn txeie(&mut self) -> _TXEIEW { + _TXEIEW { w: self } + } + #[doc = "Bit 6 - RX buffer not empty interrupt enable"] + #[inline] + pub fn rxneie(&mut self) -> _RXNEIEW { + _RXNEIEW { w: self } + } + #[doc = "Bit 5 - Error interrupt enable"] + #[inline] + pub fn errie(&mut self) -> _ERRIEW { + _ERRIEW { w: self } + } + #[doc = "Bit 4 - Frame format"] + #[inline] + pub fn frf(&mut self) -> _FRFW { + _FRFW { w: self } + } + #[doc = "Bit 2 - SS output enable"] + #[inline] + pub fn ssoe(&mut self) -> _SSOEW { + _SSOEW { w: self } + } + #[doc = "Bit 1 - Tx buffer DMA enable"] + #[inline] + pub fn txdmaen(&mut self) -> _TXDMAENW { + _TXDMAENW { w: self } + } + #[doc = "Bit 0 - Rx buffer DMA enable"] + #[inline] + pub fn rxdmaen(&mut self) -> _RXDMAENW { + _RXDMAENW { w: self } + } +} diff --git a/src/i2s2ext/crcpr/mod.rs b/src/i2s2ext/crcpr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cfe20997ff9c3910b1a5c7994de1da6cf7ddc250 --- /dev/null +++ b/src/i2s2ext/crcpr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CRCPR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CRCPOLYR { + bits: u16, +} +impl CRCPOLYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CRCPOLYW<'a> { + w: &'a mut W, +} +impl<'a> _CRCPOLYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - CRC polynomial register"] + #[inline] + pub fn crcpoly(&self) -> CRCPOLYR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CRCPOLYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 7 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - CRC polynomial register"] + #[inline] + pub fn crcpoly(&mut self) -> _CRCPOLYW { + _CRCPOLYW { w: self } + } +} diff --git a/src/i2s2ext/dr/mod.rs b/src/i2s2ext/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..21bc5622b215a1b47752c7707a3e2ae3058aeda0 --- /dev/null +++ b/src/i2s2ext/dr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DRR { + bits: u16, +} +impl DRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DRW<'a> { + w: &'a mut W, +} +impl<'a> _DRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Data register"] + #[inline] + pub fn dr(&self) -> DRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Data register"] + #[inline] + pub fn dr(&mut self) -> _DRW { + _DRW { w: self } + } +} diff --git a/src/i2s2ext/i2scfgr/mod.rs b/src/i2s2ext/i2scfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..30ae7b1318a6344b877c005f16c307e99806f734 --- /dev/null +++ b/src/i2s2ext/i2scfgr/mod.rs @@ -0,0 +1,482 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::I2SCFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct I2SMODR { + bits: bool, +} +impl I2SMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2SER { + bits: bool, +} +impl I2SER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2SCFGR { + bits: u8, +} +impl I2SCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PCMSYNCR { + bits: bool, +} +impl PCMSYNCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2SSTDR { + bits: u8, +} +impl I2SSTDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKPOLR { + bits: bool, +} +impl CKPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DATLENR { + bits: u8, +} +impl DATLENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CHLENR { + bits: bool, +} +impl CHLENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _I2SMODW<'a> { + w: &'a mut W, +} +impl<'a> _I2SMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2SEW<'a> { + w: &'a mut W, +} +impl<'a> _I2SEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2SCFGW<'a> { + w: &'a mut W, +} +impl<'a> _I2SCFGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PCMSYNCW<'a> { + w: &'a mut W, +} +impl<'a> _PCMSYNCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2SSTDW<'a> { + w: &'a mut W, +} +impl<'a> _I2SSTDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKPOLW<'a> { + w: &'a mut W, +} +impl<'a> _CKPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATLENW<'a> { + w: &'a mut W, +} +impl<'a> _DATLENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHLENW<'a> { + w: &'a mut W, +} +impl<'a> _CHLENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 11 - I2S mode selection"] + #[inline] + pub fn i2smod(&self) -> I2SMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2SMODR { bits } + } + #[doc = "Bit 10 - I2S Enable"] + #[inline] + pub fn i2se(&self) -> I2SER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2SER { bits } + } + #[doc = "Bits 8:9 - I2S configuration mode"] + #[inline] + pub fn i2scfg(&self) -> I2SCFGR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + I2SCFGR { bits } + } + #[doc = "Bit 7 - PCM frame synchronization"] + #[inline] + pub fn pcmsync(&self) -> PCMSYNCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PCMSYNCR { bits } + } + #[doc = "Bits 4:5 - I2S standard selection"] + #[inline] + pub fn i2sstd(&self) -> I2SSTDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + I2SSTDR { bits } + } + #[doc = "Bit 3 - Steady state clock polarity"] + #[inline] + pub fn ckpol(&self) -> CKPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKPOLR { bits } + } + #[doc = "Bits 1:2 - Data length to be transferred"] + #[inline] + pub fn datlen(&self) -> DATLENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DATLENR { bits } + } + #[doc = "Bit 0 - Channel length (number of bits per audio channel)"] + #[inline] + pub fn chlen(&self) -> CHLENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHLENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 11 - I2S mode selection"] + #[inline] + pub fn i2smod(&mut self) -> _I2SMODW { + _I2SMODW { w: self } + } + #[doc = "Bit 10 - I2S Enable"] + #[inline] + pub fn i2se(&mut self) -> _I2SEW { + _I2SEW { w: self } + } + #[doc = "Bits 8:9 - I2S configuration mode"] + #[inline] + pub fn i2scfg(&mut self) -> _I2SCFGW { + _I2SCFGW { w: self } + } + #[doc = "Bit 7 - PCM frame synchronization"] + #[inline] + pub fn pcmsync(&mut self) -> _PCMSYNCW { + _PCMSYNCW { w: self } + } + #[doc = "Bits 4:5 - I2S standard selection"] + #[inline] + pub fn i2sstd(&mut self) -> _I2SSTDW { + _I2SSTDW { w: self } + } + #[doc = "Bit 3 - Steady state clock polarity"] + #[inline] + pub fn ckpol(&mut self) -> _CKPOLW { + _CKPOLW { w: self } + } + #[doc = "Bits 1:2 - Data length to be transferred"] + #[inline] + pub fn datlen(&mut self) -> _DATLENW { + _DATLENW { w: self } + } + #[doc = "Bit 0 - Channel length (number of bits per audio channel)"] + #[inline] + pub fn chlen(&mut self) -> _CHLENW { + _CHLENW { w: self } + } +} diff --git a/src/i2s2ext/i2spr/mod.rs b/src/i2s2ext/i2spr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e4b5047b921e818d32abe9cd09dc3a142a77d4a9 --- /dev/null +++ b/src/i2s2ext/i2spr/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::I2SPR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCKOER { + bits: bool, +} +impl MCKOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ODDR { + bits: bool, +} +impl ODDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2SDIVR { + bits: u8, +} +impl I2SDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCKOEW<'a> { + w: &'a mut W, +} +impl<'a> _MCKOEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDW<'a> { + w: &'a mut W, +} +impl<'a> _ODDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2SDIVW<'a> { + w: &'a mut W, +} +impl<'a> _I2SDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - Master clock output enable"] + #[inline] + pub fn mckoe(&self) -> MCKOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MCKOER { bits } + } + #[doc = "Bit 8 - Odd factor for the prescaler"] + #[inline] + pub fn odd(&self) -> ODDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDR { bits } + } + #[doc = "Bits 0:7 - I2S Linear prescaler"] + #[inline] + pub fn i2sdiv(&self) -> I2SDIVR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + I2SDIVR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 10 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - Master clock output enable"] + #[inline] + pub fn mckoe(&mut self) -> _MCKOEW { + _MCKOEW { w: self } + } + #[doc = "Bit 8 - Odd factor for the prescaler"] + #[inline] + pub fn odd(&mut self) -> _ODDW { + _ODDW { w: self } + } + #[doc = "Bits 0:7 - I2S Linear prescaler"] + #[inline] + pub fn i2sdiv(&mut self) -> _I2SDIVW { + _I2SDIVW { w: self } + } +} diff --git a/src/i2s2ext/mod.rs b/src/i2s2ext/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..70e54449e96d672852eb422ea949f9c79c8a4aa2 --- /dev/null +++ b/src/i2s2ext/mod.rs @@ -0,0 +1,76 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - status register"] + pub sr: SR, + #[doc = "0x0c - data register"] + pub dr: DR, + #[doc = "0x10 - CRC polynomial register"] + pub crcpr: CRCPR, + #[doc = "0x14 - RX CRC register"] + pub rxcrcr: RXCRCR, + #[doc = "0x18 - TX CRC register"] + pub txcrcr: TXCRCR, + #[doc = "0x1c - I2S configuration register"] + pub i2scfgr: I2SCFGR, + #[doc = "0x20 - I2S prescaler register"] + pub i2spr: I2SPR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register"] +pub mod dr; +#[doc = "CRC polynomial register"] +pub struct CRCPR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "CRC polynomial register"] +pub mod crcpr; +#[doc = "RX CRC register"] +pub struct RXCRCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "RX CRC register"] +pub mod rxcrcr; +#[doc = "TX CRC register"] +pub struct TXCRCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "TX CRC register"] +pub mod txcrcr; +#[doc = "I2S configuration register"] +pub struct I2SCFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "I2S configuration register"] +pub mod i2scfgr; +#[doc = "I2S prescaler register"] +pub struct I2SPR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "I2S prescaler register"] +pub mod i2spr; diff --git a/src/i2s2ext/rxcrcr/mod.rs b/src/i2s2ext/rxcrcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..06d5c7f775dfb06c5014d5f432f278ef595bcf03 --- /dev/null +++ b/src/i2s2ext/rxcrcr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RXCRCR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RXCRCR { + bits: u16, +} +impl RXCRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Rx CRC register"] + #[inline] + pub fn rx_crc(&self) -> RXCRCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + RXCRCR { bits } + } +} diff --git a/src/i2s2ext/sr/mod.rs b/src/i2s2ext/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a3dcbce5a81dffcfb644118fef62897ff8f08b01 --- /dev/null +++ b/src/i2s2ext/sr/mod.rs @@ -0,0 +1,371 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIFRFER { + bits: bool, +} +impl TIFRFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BSYR { + bits: bool, +} +impl BSYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRR { + bits: bool, +} +impl OVRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MODFR { + bits: bool, +} +impl MODFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCERRR { + bits: bool, +} +impl CRCERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDRR { + bits: bool, +} +impl UDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHSIDER { + bits: bool, +} +impl CHSIDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXER { + bits: bool, +} +impl TXER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNER { + bits: bool, +} +impl RXNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CRCERRW<'a> { + w: &'a mut W, +} +impl<'a> _CRCERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 8 - TI frame format error"] + #[inline] + pub fn tifrfe(&self) -> TIFRFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFRFER { bits } + } + #[doc = "Bit 7 - Busy flag"] + #[inline] + pub fn bsy(&self) -> BSYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BSYR { bits } + } + #[doc = "Bit 6 - Overrun flag"] + #[inline] + pub fn ovr(&self) -> OVRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRR { bits } + } + #[doc = "Bit 5 - Mode fault"] + #[inline] + pub fn modf(&self) -> MODFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MODFR { bits } + } + #[doc = "Bit 4 - CRC error flag"] + #[inline] + pub fn crcerr(&self) -> CRCERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCERRR { bits } + } + #[doc = "Bit 3 - Underrun flag"] + #[inline] + pub fn udr(&self) -> UDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDRR { bits } + } + #[doc = "Bit 2 - Channel side"] + #[inline] + pub fn chside(&self) -> CHSIDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHSIDER { bits } + } + #[doc = "Bit 1 - Transmit buffer empty"] + #[inline] + pub fn txe(&self) -> TXER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXER { bits } + } + #[doc = "Bit 0 - Receive buffer not empty"] + #[inline] + pub fn rxne(&self) -> RXNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 4 - CRC error flag"] + #[inline] + pub fn crcerr(&mut self) -> _CRCERRW { + _CRCERRW { w: self } + } +} diff --git a/src/i2s2ext/txcrcr/mod.rs b/src/i2s2ext/txcrcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1feab970a6ddc333caa9bec08ccd52dbc3d4c586 --- /dev/null +++ b/src/i2s2ext/txcrcr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::TXCRCR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct TXCRCR { + bits: u16, +} +impl TXCRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Tx CRC register"] + #[inline] + pub fn tx_crc(&self) -> TXCRCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TXCRCR { bits } + } +} diff --git a/src/interrupt/mod.rs b/src/interrupt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/src/interrupt/mod.rs @@ -0,0 +1 @@ + diff --git a/src/iwdg/kr/mod.rs b/src/iwdg/kr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5d0c8602c14de8968b05609600084625dfc51415 --- /dev/null +++ b/src/iwdg/kr/mod.rs @@ -0,0 +1,49 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::KR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _KEYW<'a> { + w: &'a mut W, +} +impl<'a> _KEYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Key value"] + #[inline] + pub fn key(&mut self) -> _KEYW { + _KEYW { w: self } + } +} diff --git a/src/iwdg/mod.rs b/src/iwdg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a8df234f2c0ca7c3de3726ba665db5f1e3324758 --- /dev/null +++ b/src/iwdg/mod.rs @@ -0,0 +1,36 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Key register"] + pub kr: KR, + #[doc = "0x04 - Prescaler register"] + pub pr: PR, + #[doc = "0x08 - Reload register"] + pub rlr: RLR, + #[doc = "0x0c - Status register"] + pub sr: SR, +} +#[doc = "Key register"] +pub struct KR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Key register"] +pub mod kr; +#[doc = "Prescaler register"] +pub struct PR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Prescaler register"] +pub mod pr; +#[doc = "Reload register"] +pub struct RLR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Reload register"] +pub mod rlr; +#[doc = "Status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register"] +pub mod sr; diff --git a/src/iwdg/pr/mod.rs b/src/iwdg/pr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0ac128fc91bc15cdf6c9f0a137291631a9f6179b --- /dev/null +++ b/src/iwdg/pr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PRR { + bits: u8, +} +impl PRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PRW<'a> { + w: &'a mut W, +} +impl<'a> _PRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:2 - Prescaler divider"] + #[inline] + pub fn pr(&self) -> PRR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:2 - Prescaler divider"] + #[inline] + pub fn pr(&mut self) -> _PRW { + _PRW { w: self } + } +} diff --git a/src/iwdg/rlr/mod.rs b/src/iwdg/rlr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..75ed6843f0d3f8818d04a2544a448886c88d867a --- /dev/null +++ b/src/iwdg/rlr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::RLR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RLR { + bits: u16, +} +impl RLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RLW<'a> { + w: &'a mut W, +} +impl<'a> _RLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Watchdog counter reload value"] + #[inline] + pub fn rl(&self) -> RLR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + RLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4095 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Watchdog counter reload value"] + #[inline] + pub fn rl(&mut self) -> _RLW { + _RLW { w: self } + } +} diff --git a/src/iwdg/sr/mod.rs b/src/iwdg/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..30239ca0567e5bbbe773eb90ef9a242ed8a437f6 --- /dev/null +++ b/src/iwdg/sr/mod.rs @@ -0,0 +1,82 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::SR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RVUR { + bits: bool, +} +impl RVUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PVUR { + bits: bool, +} +impl PVUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 1 - Watchdog counter reload value update"] + #[inline] + pub fn rvu(&self) -> RVUR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RVUR { bits } + } + #[doc = "Bit 0 - Watchdog prescaler value update"] + #[inline] + pub fn pvu(&self) -> PVUR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PVUR { bits } + } +} diff --git a/src/lptim/arr/mod.rs b/src/lptim/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b151bedbdda477074698c9ef00d8c401619d0870 --- /dev/null +++ b/src/lptim/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/lptim/cfgr/mod.rs b/src/lptim/cfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..65a2dd006cfd4c31d4f343b46a5700cd1829211a --- /dev/null +++ b/src/lptim/cfgr/mod.rs @@ -0,0 +1,723 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ENCR { + bits: bool, +} +impl ENCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct COUNTMODER { + bits: bool, +} +impl COUNTMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PRELOADR { + bits: bool, +} +impl PRELOADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAVPOLR { + bits: bool, +} +impl WAVPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAVER { + bits: bool, +} +impl WAVER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMOUTR { + bits: bool, +} +impl TIMOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRIGENR { + bits: u8, +} +impl TRIGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TRIGSELR { + bits: u8, +} +impl TRIGSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PRESCR { + bits: u8, +} +impl PRESCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TRGFLTR { + bits: u8, +} +impl TRGFLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKFLTR { + bits: u8, +} +impl CKFLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKPOLR { + bits: u8, +} +impl CKPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKSELR { + bits: bool, +} +impl CKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ENCW<'a> { + w: &'a mut W, +} +impl<'a> _ENCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COUNTMODEW<'a> { + w: &'a mut W, +} +impl<'a> _COUNTMODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRELOADW<'a> { + w: &'a mut W, +} +impl<'a> _PRELOADW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAVPOLW<'a> { + w: &'a mut W, +} +impl<'a> _WAVPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAVEW<'a> { + w: &'a mut W, +} +impl<'a> _WAVEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMOUTW<'a> { + w: &'a mut W, +} +impl<'a> _TIMOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRIGENW<'a> { + w: &'a mut W, +} +impl<'a> _TRIGENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRIGSELW<'a> { + w: &'a mut W, +} +impl<'a> _TRIGSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRESCW<'a> { + w: &'a mut W, +} +impl<'a> _PRESCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRGFLTW<'a> { + w: &'a mut W, +} +impl<'a> _TRGFLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKFLTW<'a> { + w: &'a mut W, +} +impl<'a> _CKFLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKPOLW<'a> { + w: &'a mut W, +} +impl<'a> _CKPOLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKSELW<'a> { + w: &'a mut W, +} +impl<'a> _CKSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 24 - Encoder mode enable"] + #[inline] + pub fn enc(&self) -> ENCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENCR { bits } + } + #[doc = "Bit 23 - counter mode enabled"] + #[inline] + pub fn countmode(&self) -> COUNTMODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COUNTMODER { bits } + } + #[doc = "Bit 22 - Registers update mode"] + #[inline] + pub fn preload(&self) -> PRELOADR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PRELOADR { bits } + } + #[doc = "Bit 21 - Waveform shape polarity"] + #[inline] + pub fn wavpol(&self) -> WAVPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAVPOLR { bits } + } + #[doc = "Bit 20 - Waveform shape"] + #[inline] + pub fn wave(&self) -> WAVER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAVER { bits } + } + #[doc = "Bit 19 - Timeout enable"] + #[inline] + pub fn timout(&self) -> TIMOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIMOUTR { bits } + } + #[doc = "Bits 17:18 - Trigger enable and polarity"] + #[inline] + pub fn trigen(&self) -> TRIGENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRIGENR { bits } + } + #[doc = "Bits 13:15 - Trigger selector"] + #[inline] + pub fn trigsel(&self) -> TRIGSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRIGSELR { bits } + } + #[doc = "Bits 9:11 - Clock prescaler"] + #[inline] + pub fn presc(&self) -> PRESCR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRESCR { bits } + } + #[doc = "Bits 6:7 - Configurable digital filter for trigger"] + #[inline] + pub fn trgflt(&self) -> TRGFLTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRGFLTR { bits } + } + #[doc = "Bits 3:4 - Configurable digital filter for external clock"] + #[inline] + pub fn ckflt(&self) -> CKFLTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKFLTR { bits } + } + #[doc = "Bits 1:2 - Clock Polarity"] + #[inline] + pub fn ckpol(&self) -> CKPOLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKPOLR { bits } + } + #[doc = "Bit 0 - Clock selector"] + #[inline] + pub fn cksel(&self) -> CKSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKSELR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 24 - Encoder mode enable"] + #[inline] + pub fn enc(&mut self) -> _ENCW { + _ENCW { w: self } + } + #[doc = "Bit 23 - counter mode enabled"] + #[inline] + pub fn countmode(&mut self) -> _COUNTMODEW { + _COUNTMODEW { w: self } + } + #[doc = "Bit 22 - Registers update mode"] + #[inline] + pub fn preload(&mut self) -> _PRELOADW { + _PRELOADW { w: self } + } + #[doc = "Bit 21 - Waveform shape polarity"] + #[inline] + pub fn wavpol(&mut self) -> _WAVPOLW { + _WAVPOLW { w: self } + } + #[doc = "Bit 20 - Waveform shape"] + #[inline] + pub fn wave(&mut self) -> _WAVEW { + _WAVEW { w: self } + } + #[doc = "Bit 19 - Timeout enable"] + #[inline] + pub fn timout(&mut self) -> _TIMOUTW { + _TIMOUTW { w: self } + } + #[doc = "Bits 17:18 - Trigger enable and polarity"] + #[inline] + pub fn trigen(&mut self) -> _TRIGENW { + _TRIGENW { w: self } + } + #[doc = "Bits 13:15 - Trigger selector"] + #[inline] + pub fn trigsel(&mut self) -> _TRIGSELW { + _TRIGSELW { w: self } + } + #[doc = "Bits 9:11 - Clock prescaler"] + #[inline] + pub fn presc(&mut self) -> _PRESCW { + _PRESCW { w: self } + } + #[doc = "Bits 6:7 - Configurable digital filter for trigger"] + #[inline] + pub fn trgflt(&mut self) -> _TRGFLTW { + _TRGFLTW { w: self } + } + #[doc = "Bits 3:4 - Configurable digital filter for external clock"] + #[inline] + pub fn ckflt(&mut self) -> _CKFLTW { + _CKFLTW { w: self } + } + #[doc = "Bits 1:2 - Clock Polarity"] + #[inline] + pub fn ckpol(&mut self) -> _CKPOLW { + _CKPOLW { w: self } + } + #[doc = "Bit 0 - Clock selector"] + #[inline] + pub fn cksel(&mut self) -> _CKSELW { + _CKSELW { w: self } + } +} diff --git a/src/lptim/cmp/mod.rs b/src/lptim/cmp/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c8b8a592985c471127db744535c3e629f1fc32e5 --- /dev/null +++ b/src/lptim/cmp/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CMP { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CMPR { + bits: u16, +} +impl CMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CMPW<'a> { + w: &'a mut W, +} +impl<'a> _CMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Compare value"] + #[inline] + pub fn cmp(&self) -> CMPR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CMPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Compare value"] + #[inline] + pub fn cmp(&mut self) -> _CMPW { + _CMPW { w: self } + } +} diff --git a/src/lptim/cnt/mod.rs b/src/lptim/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2a7f7ad481e6794b9a89d7e4acaab7a8a1d65962 --- /dev/null +++ b/src/lptim/cnt/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::CNT { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} diff --git a/src/lptim/cr/mod.rs b/src/lptim/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e6eb7b63a1ca91c767dc1c4d5e6023bee2dda1c8 --- /dev/null +++ b/src/lptim/cr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTSTRTR { + bits: bool, +} +impl CNTSTRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNGSTRTR { + bits: bool, +} +impl SNGSTRTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENABLER { + bits: bool, +} +impl ENABLER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CNTSTRTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTSTRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNGSTRTW<'a> { + w: &'a mut W, +} +impl<'a> _SNGSTRTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENABLEW<'a> { + w: &'a mut W, +} +impl<'a> _ENABLEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 2 - Timer start in continuous mode"] + #[inline] + pub fn cntstrt(&self) -> CNTSTRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNTSTRTR { bits } + } + #[doc = "Bit 1 - LPTIM start in single mode"] + #[inline] + pub fn sngstrt(&self) -> SNGSTRTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SNGSTRTR { bits } + } + #[doc = "Bit 0 - LPTIM Enable"] + #[inline] + pub fn enable(&self) -> ENABLER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENABLER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 2 - Timer start in continuous mode"] + #[inline] + pub fn cntstrt(&mut self) -> _CNTSTRTW { + _CNTSTRTW { w: self } + } + #[doc = "Bit 1 - LPTIM start in single mode"] + #[inline] + pub fn sngstrt(&mut self) -> _SNGSTRTW { + _SNGSTRTW { w: self } + } + #[doc = "Bit 0 - LPTIM Enable"] + #[inline] + pub fn enable(&mut self) -> _ENABLEW { + _ENABLEW { w: self } + } +} diff --git a/src/lptim/icr/mod.rs b/src/lptim/icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4e6316b286874d8baf86258cb65b6418490cd598 --- /dev/null +++ b/src/lptim/icr/mod.rs @@ -0,0 +1,225 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ICR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _DOWNCFW<'a> { + w: &'a mut W, +} +impl<'a> _DOWNCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UPCFW<'a> { + w: &'a mut W, +} +impl<'a> _UPCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARROKCFW<'a> { + w: &'a mut W, +} +impl<'a> _ARROKCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMPOKCFW<'a> { + w: &'a mut W, +} +impl<'a> _CMPOKCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTTRIGCFW<'a> { + w: &'a mut W, +} +impl<'a> _EXTTRIGCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARRMCFW<'a> { + w: &'a mut W, +} +impl<'a> _ARRMCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMPMCFW<'a> { + w: &'a mut W, +} +impl<'a> _CMPMCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Direction change to down Clear Flag"] + #[inline] + pub fn downcf(&mut self) -> _DOWNCFW { + _DOWNCFW { w: self } + } + #[doc = "Bit 5 - Direction change to UP Clear Flag"] + #[inline] + pub fn upcf(&mut self) -> _UPCFW { + _UPCFW { w: self } + } + #[doc = "Bit 4 - Autoreload register update OK Clear Flag"] + #[inline] + pub fn arrokcf(&mut self) -> _ARROKCFW { + _ARROKCFW { w: self } + } + #[doc = "Bit 3 - Compare register update OK Clear Flag"] + #[inline] + pub fn cmpokcf(&mut self) -> _CMPOKCFW { + _CMPOKCFW { w: self } + } + #[doc = "Bit 2 - External trigger valid edge Clear Flag"] + #[inline] + pub fn exttrigcf(&mut self) -> _EXTTRIGCFW { + _EXTTRIGCFW { w: self } + } + #[doc = "Bit 1 - Autoreload match Clear Flag"] + #[inline] + pub fn arrmcf(&mut self) -> _ARRMCFW { + _ARRMCFW { w: self } + } + #[doc = "Bit 0 - compare match Clear Flag"] + #[inline] + pub fn cmpmcf(&mut self) -> _CMPMCFW { + _CMPMCFW { w: self } + } +} diff --git a/src/lptim/ier/mod.rs b/src/lptim/ier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f817df266cb1ce9d1c20488c74bc489f3ac5e80d --- /dev/null +++ b/src/lptim/ier/mod.rs @@ -0,0 +1,477 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::IER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DOWNIER { + bits: bool, +} +impl DOWNIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UPIER { + bits: bool, +} +impl UPIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARROKIER { + bits: bool, +} +impl ARROKIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMPOKIER { + bits: bool, +} +impl CMPOKIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTTRIGIER { + bits: bool, +} +impl EXTTRIGIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARRMIER { + bits: bool, +} +impl ARRMIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMPMIER { + bits: bool, +} +impl CMPMIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DOWNIEW<'a> { + w: &'a mut W, +} +impl<'a> _DOWNIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UPIEW<'a> { + w: &'a mut W, +} +impl<'a> _UPIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARROKIEW<'a> { + w: &'a mut W, +} +impl<'a> _ARROKIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMPOKIEW<'a> { + w: &'a mut W, +} +impl<'a> _CMPOKIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTTRIGIEW<'a> { + w: &'a mut W, +} +impl<'a> _EXTTRIGIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARRMIEW<'a> { + w: &'a mut W, +} +impl<'a> _ARRMIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMPMIEW<'a> { + w: &'a mut W, +} +impl<'a> _CMPMIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Direction change to down Interrupt Enable"] + #[inline] + pub fn downie(&self) -> DOWNIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DOWNIER { bits } + } + #[doc = "Bit 5 - Direction change to UP Interrupt Enable"] + #[inline] + pub fn upie(&self) -> UPIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UPIER { bits } + } + #[doc = "Bit 4 - Autoreload register update OK Interrupt Enable"] + #[inline] + pub fn arrokie(&self) -> ARROKIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARROKIER { bits } + } + #[doc = "Bit 3 - Compare register update OK Interrupt Enable"] + #[inline] + pub fn cmpokie(&self) -> CMPOKIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMPOKIER { bits } + } + #[doc = "Bit 2 - External trigger valid edge Interrupt Enable"] + #[inline] + pub fn exttrigie(&self) -> EXTTRIGIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTTRIGIER { bits } + } + #[doc = "Bit 1 - Autoreload match Interrupt Enable"] + #[inline] + pub fn arrmie(&self) -> ARRMIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARRMIER { bits } + } + #[doc = "Bit 0 - Compare match Interrupt Enable"] + #[inline] + pub fn cmpmie(&self) -> CMPMIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMPMIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Direction change to down Interrupt Enable"] + #[inline] + pub fn downie(&mut self) -> _DOWNIEW { + _DOWNIEW { w: self } + } + #[doc = "Bit 5 - Direction change to UP Interrupt Enable"] + #[inline] + pub fn upie(&mut self) -> _UPIEW { + _UPIEW { w: self } + } + #[doc = "Bit 4 - Autoreload register update OK Interrupt Enable"] + #[inline] + pub fn arrokie(&mut self) -> _ARROKIEW { + _ARROKIEW { w: self } + } + #[doc = "Bit 3 - Compare register update OK Interrupt Enable"] + #[inline] + pub fn cmpokie(&mut self) -> _CMPOKIEW { + _CMPOKIEW { w: self } + } + #[doc = "Bit 2 - External trigger valid edge Interrupt Enable"] + #[inline] + pub fn exttrigie(&mut self) -> _EXTTRIGIEW { + _EXTTRIGIEW { w: self } + } + #[doc = "Bit 1 - Autoreload match Interrupt Enable"] + #[inline] + pub fn arrmie(&mut self) -> _ARRMIEW { + _ARRMIEW { w: self } + } + #[doc = "Bit 0 - Compare match Interrupt Enable"] + #[inline] + pub fn cmpmie(&mut self) -> _CMPMIEW { + _CMPMIEW { w: self } + } +} diff --git a/src/lptim/isr/mod.rs b/src/lptim/isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..32fe225435ff15f346d3f14c2ffa10342eec6b82 --- /dev/null +++ b/src/lptim/isr/mod.rs @@ -0,0 +1,237 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::ISR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DOWNR { + bits: bool, +} +impl DOWNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UPR { + bits: bool, +} +impl UPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARROKR { + bits: bool, +} +impl ARROKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMPOKR { + bits: bool, +} +impl CMPOKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTTRIGR { + bits: bool, +} +impl EXTTRIGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARRMR { + bits: bool, +} +impl ARRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMPMR { + bits: bool, +} +impl CMPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Counter direction change up to down"] + #[inline] + pub fn down(&self) -> DOWNR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DOWNR { bits } + } + #[doc = "Bit 5 - Counter direction change down to up"] + #[inline] + pub fn up(&self) -> UPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UPR { bits } + } + #[doc = "Bit 4 - Autoreload register update OK"] + #[inline] + pub fn arrok(&self) -> ARROKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARROKR { bits } + } + #[doc = "Bit 3 - Compare register update OK"] + #[inline] + pub fn cmpok(&self) -> CMPOKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMPOKR { bits } + } + #[doc = "Bit 2 - External trigger edge event"] + #[inline] + pub fn exttrig(&self) -> EXTTRIGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTTRIGR { bits } + } + #[doc = "Bit 1 - Autoreload match"] + #[inline] + pub fn arrm(&self) -> ARRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARRMR { bits } + } + #[doc = "Bit 0 - Compare match"] + #[inline] + pub fn cmpm(&self) -> CMPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMPMR { bits } + } +} diff --git a/src/lptim/mod.rs b/src/lptim/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..706639e3d6442570241ccda33b6d52059c2afe68 --- /dev/null +++ b/src/lptim/mod.rs @@ -0,0 +1,68 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Interrupt and Status Register"] + pub isr: ISR, + #[doc = "0x04 - Interrupt Clear Register"] + pub icr: ICR, + #[doc = "0x08 - Interrupt Enable Register"] + pub ier: IER, + #[doc = "0x0c - Configuration Register"] + pub cfgr: CFGR, + #[doc = "0x10 - Control Register"] + pub cr: CR, + #[doc = "0x14 - Compare Register"] + pub cmp: CMP, + #[doc = "0x18 - Autoreload Register"] + pub arr: ARR, + #[doc = "0x1c - Counter Register"] + pub cnt: CNT, +} +#[doc = "Interrupt and Status Register"] +pub struct ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt and Status Register"] +pub mod isr; +#[doc = "Interrupt Clear Register"] +pub struct ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt Clear Register"] +pub mod icr; +#[doc = "Interrupt Enable Register"] +pub struct IER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Interrupt Enable Register"] +pub mod ier; +#[doc = "Configuration Register"] +pub struct CFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Configuration Register"] +pub mod cfgr; +#[doc = "Control Register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control Register"] +pub mod cr; +#[doc = "Compare Register"] +pub struct CMP { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Compare Register"] +pub mod cmp; +#[doc = "Autoreload Register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Autoreload Register"] +pub mod arr; +#[doc = "Counter Register"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Counter Register"] +pub mod cnt; diff --git a/src/otg_fs_device/diepctl1/mod.rs b/src/otg_fs_device/diepctl1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9107ccfa64ac91aeb5710b42625978642204350b --- /dev/null +++ b/src/otg_fs_device/diepctl1/mod.rs @@ -0,0 +1,597 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPCTL1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFNUMR { + bits: u8, +} +impl TXFNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRM_SD1PIDW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRM_SD1PIDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFNUMW<'a> { + w: &'a mut W, +} +impl<'a> _TXFNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&self) -> TXFNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXFNUMR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM/SD1PID"] + #[inline] + pub fn soddfrm_sd1pid(&mut self) -> _SODDFRM_SD1PIDW { + _SODDFRM_SD1PIDW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&mut self) -> _TXFNUMW { + _TXFNUMW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/diepctl2/mod.rs b/src/otg_fs_device/diepctl2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d1579f4ca7d36d2af9e24f64bfb5c154b4110775 --- /dev/null +++ b/src/otg_fs_device/diepctl2/mod.rs @@ -0,0 +1,597 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPCTL2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFNUMR { + bits: u8, +} +impl TXFNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFNUMW<'a> { + w: &'a mut W, +} +impl<'a> _TXFNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&self) -> TXFNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXFNUMR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM"] + #[inline] + pub fn soddfrm(&mut self) -> _SODDFRMW { + _SODDFRMW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&mut self) -> _TXFNUMW { + _TXFNUMW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/diepctl3/mod.rs b/src/otg_fs_device/diepctl3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..481136eeaf527eed00450c55383e22eebb6ac394 --- /dev/null +++ b/src/otg_fs_device/diepctl3/mod.rs @@ -0,0 +1,597 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPCTL3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFNUMR { + bits: u8, +} +impl TXFNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFNUMW<'a> { + w: &'a mut W, +} +impl<'a> _TXFNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&self) -> TXFNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXFNUMR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM"] + #[inline] + pub fn soddfrm(&mut self) -> _SODDFRMW { + _SODDFRMW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bits 22:25 - TXFNUM"] + #[inline] + pub fn txfnum(&mut self) -> _TXFNUMW { + _TXFNUMW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/diepempmsk/mod.rs b/src/otg_fs_device/diepempmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eeec3662097be59ad1303a06496dc3332f544c0b --- /dev/null +++ b/src/otg_fs_device/diepempmsk/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPEMPMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INEPTXFEMR { + bits: u16, +} +impl INEPTXFEMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INEPTXFEMW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXFEMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN EP Tx FIFO empty interrupt mask bits"] + #[inline] + pub fn ineptxfem(&self) -> INEPTXFEMR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXFEMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - IN EP Tx FIFO empty interrupt mask bits"] + #[inline] + pub fn ineptxfem(&mut self) -> _INEPTXFEMW { + _INEPTXFEMW { w: self } + } +} diff --git a/src/otg_fs_device/diepint0/mod.rs b/src/otg_fs_device/diepint0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8f53a31af86b8d6347b270881aecd195bed2ef99 --- /dev/null +++ b/src/otg_fs_device/diepint0/mod.rs @@ -0,0 +1,390 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPINT0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXFER { + bits: bool, +} +impl TXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNER { + bits: bool, +} +impl INEPNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITTXFER { + bits: bool, +} +impl ITTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOCR { + bits: bool, +} +impl TOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _INEPNEW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITTXFEW<'a> { + w: &'a mut W, +} +impl<'a> _ITTXFEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOCW<'a> { + w: &'a mut W, +} +impl<'a> _TOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TXFE"] + #[inline] + pub fn txfe(&self) -> TXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFER { bits } + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&self) -> INEPNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNER { bits } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&self) -> ITTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITTXFER { bits } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&self) -> TOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOCR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&mut self) -> _INEPNEW { + _INEPNEW { w: self } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&mut self) -> _ITTXFEW { + _ITTXFEW { w: self } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&mut self) -> _TOCW { + _TOCW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/diepint1/mod.rs b/src/otg_fs_device/diepint1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f04a164f30a603bc778dc23cc2d0c57731d6832a --- /dev/null +++ b/src/otg_fs_device/diepint1/mod.rs @@ -0,0 +1,390 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPINT1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXFER { + bits: bool, +} +impl TXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNER { + bits: bool, +} +impl INEPNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITTXFER { + bits: bool, +} +impl ITTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOCR { + bits: bool, +} +impl TOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _INEPNEW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITTXFEW<'a> { + w: &'a mut W, +} +impl<'a> _ITTXFEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOCW<'a> { + w: &'a mut W, +} +impl<'a> _TOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TXFE"] + #[inline] + pub fn txfe(&self) -> TXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFER { bits } + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&self) -> INEPNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNER { bits } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&self) -> ITTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITTXFER { bits } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&self) -> TOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOCR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&mut self) -> _INEPNEW { + _INEPNEW { w: self } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&mut self) -> _ITTXFEW { + _ITTXFEW { w: self } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&mut self) -> _TOCW { + _TOCW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/diepint2/mod.rs b/src/otg_fs_device/diepint2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..856d3ad8d80ea92b449ac0738fed36bb9c867cf9 --- /dev/null +++ b/src/otg_fs_device/diepint2/mod.rs @@ -0,0 +1,390 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPINT2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXFER { + bits: bool, +} +impl TXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNER { + bits: bool, +} +impl INEPNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITTXFER { + bits: bool, +} +impl ITTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOCR { + bits: bool, +} +impl TOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _INEPNEW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITTXFEW<'a> { + w: &'a mut W, +} +impl<'a> _ITTXFEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOCW<'a> { + w: &'a mut W, +} +impl<'a> _TOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TXFE"] + #[inline] + pub fn txfe(&self) -> TXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFER { bits } + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&self) -> INEPNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNER { bits } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&self) -> ITTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITTXFER { bits } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&self) -> TOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOCR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&mut self) -> _INEPNEW { + _INEPNEW { w: self } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&mut self) -> _ITTXFEW { + _ITTXFEW { w: self } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&mut self) -> _TOCW { + _TOCW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/diepint3/mod.rs b/src/otg_fs_device/diepint3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..942a76cbe02996e081fd1834d55908041552f330 --- /dev/null +++ b/src/otg_fs_device/diepint3/mod.rs @@ -0,0 +1,390 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPINT3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TXFER { + bits: bool, +} +impl TXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNER { + bits: bool, +} +impl INEPNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITTXFER { + bits: bool, +} +impl ITTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOCR { + bits: bool, +} +impl TOCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _INEPNEW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITTXFEW<'a> { + w: &'a mut W, +} +impl<'a> _ITTXFEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOCW<'a> { + w: &'a mut W, +} +impl<'a> _TOCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TXFE"] + #[inline] + pub fn txfe(&self) -> TXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFER { bits } + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&self) -> INEPNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNER { bits } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&self) -> ITTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITTXFER { bits } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&self) -> TOCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOCR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - INEPNE"] + #[inline] + pub fn inepne(&mut self) -> _INEPNEW { + _INEPNEW { w: self } + } + #[doc = "Bit 4 - ITTXFE"] + #[inline] + pub fn ittxfe(&mut self) -> _ITTXFEW { + _ITTXFEW { w: self } + } + #[doc = "Bit 3 - TOC"] + #[inline] + pub fn toc(&mut self) -> _TOCW { + _TOCW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/dieptsiz0/mod.rs b/src/otg_fs_device/dieptsiz0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d4c9a79f15fae8fabd5e9ee3577d32e5819adbbd --- /dev/null +++ b/src/otg_fs_device/dieptsiz0/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPTSIZ0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u8, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u8, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 19:20 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:6 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 19:20 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:6 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/dieptsiz1/mod.rs b/src/otg_fs_device/dieptsiz1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b0fad8df5f3fe119df14651bbf7c43a931e49d24 --- /dev/null +++ b/src/otg_fs_device/dieptsiz1/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPTSIZ1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/dieptsiz2/mod.rs b/src/otg_fs_device/dieptsiz2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0bdf35692332a279851b390e4823e838c0e3462a --- /dev/null +++ b/src/otg_fs_device/dieptsiz2/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPTSIZ2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/dieptsiz3/mod.rs b/src/otg_fs_device/dieptsiz3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0438cd618e2627ce8263274ae060ce05cb59f1b4 --- /dev/null +++ b/src/otg_fs_device/dieptsiz3/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIEPTSIZ3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Multi count"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doepctl0/mod.rs b/src/otg_fs_device/doepctl0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f04d80c3a20fc596208f645e26ea730f8ce20e85 --- /dev/null +++ b/src/otg_fs_device/doepctl0/mod.rs @@ -0,0 +1,401 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPCTL0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNPMR { + bits: bool, +} +impl SNPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u8, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNPMW<'a> { + w: &'a mut W, +} +impl<'a> _SNPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&self) -> SNPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SNPMR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:1 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 32768 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&mut self) -> _SNPMW { + _SNPMW { w: self } + } +} diff --git a/src/otg_fs_device/doepctl1/mod.rs b/src/otg_fs_device/doepctl1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3bec4ba6da1b5eae315f309f305239dca12091b6 --- /dev/null +++ b/src/otg_fs_device/doepctl1/mod.rs @@ -0,0 +1,615 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPCTL1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNPMR { + bits: bool, +} +impl SNPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNPMW<'a> { + w: &'a mut W, +} +impl<'a> _SNPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&self) -> SNPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SNPMR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM"] + #[inline] + pub fn soddfrm(&mut self) -> _SODDFRMW { + _SODDFRMW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&mut self) -> _SNPMW { + _SNPMW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doepctl2/mod.rs b/src/otg_fs_device/doepctl2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..100ea74205c7e9ec8ed4e0ef356ae0148f0badc1 --- /dev/null +++ b/src/otg_fs_device/doepctl2/mod.rs @@ -0,0 +1,615 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPCTL2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNPMR { + bits: bool, +} +impl SNPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNPMW<'a> { + w: &'a mut W, +} +impl<'a> _SNPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&self) -> SNPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SNPMR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM"] + #[inline] + pub fn soddfrm(&mut self) -> _SODDFRMW { + _SODDFRMW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&mut self) -> _SNPMW { + _SNPMW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doepctl3/mod.rs b/src/otg_fs_device/doepctl3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bffe0cc5771e529502570d89e5281a6ac329638a --- /dev/null +++ b/src/otg_fs_device/doepctl3/mod.rs @@ -0,0 +1,615 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPCTL3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SNPMR { + bits: bool, +} +impl SNPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EONUM_DPIDR { + bits: bool, +} +impl EONUM_DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EPENAW<'a> { + w: &'a mut W, +} +impl<'a> _EPENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SD0PID_SEVNFRMW<'a> { + w: &'a mut W, +} +impl<'a> _SD0PID_SEVNFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNPMW<'a> { + w: &'a mut W, +} +impl<'a> _SNPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBAEPW<'a> { + w: &'a mut W, +} +impl<'a> _USBAEPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&self) -> SNPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SNPMR { bits } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 17 - NAKSTS"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bit 16 - EONUM/DPID"] + #[inline] + pub fn eonum_dpid(&self) -> EONUM_DPIDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EONUM_DPIDR { bits } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - EPENA"] + #[inline] + pub fn epena(&mut self) -> _EPENAW { + _EPENAW { w: self } + } + #[doc = "Bit 30 - EPDIS"] + #[inline] + pub fn epdis(&mut self) -> _EPDISW { + _EPDISW { w: self } + } + #[doc = "Bit 29 - SODDFRM"] + #[inline] + pub fn soddfrm(&mut self) -> _SODDFRMW { + _SODDFRMW { w: self } + } + #[doc = "Bit 28 - SD0PID/SEVNFRM"] + #[inline] + pub fn sd0pid_sevnfrm(&mut self) -> _SD0PID_SEVNFRMW { + _SD0PID_SEVNFRMW { w: self } + } + #[doc = "Bit 27 - SNAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } + #[doc = "Bit 26 - CNAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bit 21 - Stall"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 20 - SNPM"] + #[inline] + pub fn snpm(&mut self) -> _SNPMW { + _SNPMW { w: self } + } + #[doc = "Bits 18:19 - EPTYP"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bit 15 - USBAEP"] + #[inline] + pub fn usbaep(&mut self) -> _USBAEPW { + _USBAEPW { w: self } + } + #[doc = "Bits 0:10 - MPSIZ"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doepint0/mod.rs b/src/otg_fs_device/doepint0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fbd81699efb7d663497c772730c2bcd718b63cda --- /dev/null +++ b/src/otg_fs_device/doepint0/mod.rs @@ -0,0 +1,359 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPINT0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct B2BSTUPR { + bits: bool, +} +impl B2BSTUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTEPDISR { + bits: bool, +} +impl OTEPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STUPR { + bits: bool, +} +impl STUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _B2BSTUPW<'a> { + w: &'a mut W, +} +impl<'a> _B2BSTUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTEPDISW<'a> { + w: &'a mut W, +} +impl<'a> _OTEPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STUPW<'a> { + w: &'a mut W, +} +impl<'a> _STUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&self) -> B2BSTUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + B2BSTUPR { bits } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&self) -> OTEPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTEPDISR { bits } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&self) -> STUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STUPR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&mut self) -> _B2BSTUPW { + _B2BSTUPW { w: self } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&mut self) -> _OTEPDISW { + _OTEPDISW { w: self } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&mut self) -> _STUPW { + _STUPW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/doepint1/mod.rs b/src/otg_fs_device/doepint1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9b591610808846106eed36e6eb60c35f3901899e --- /dev/null +++ b/src/otg_fs_device/doepint1/mod.rs @@ -0,0 +1,359 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPINT1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct B2BSTUPR { + bits: bool, +} +impl B2BSTUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTEPDISR { + bits: bool, +} +impl OTEPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STUPR { + bits: bool, +} +impl STUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _B2BSTUPW<'a> { + w: &'a mut W, +} +impl<'a> _B2BSTUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTEPDISW<'a> { + w: &'a mut W, +} +impl<'a> _OTEPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STUPW<'a> { + w: &'a mut W, +} +impl<'a> _STUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&self) -> B2BSTUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + B2BSTUPR { bits } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&self) -> OTEPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTEPDISR { bits } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&self) -> STUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STUPR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&mut self) -> _B2BSTUPW { + _B2BSTUPW { w: self } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&mut self) -> _OTEPDISW { + _OTEPDISW { w: self } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&mut self) -> _STUPW { + _STUPW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/doepint2/mod.rs b/src/otg_fs_device/doepint2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a74e1072d92e19563cc33a047a31a86c4b5bcc78 --- /dev/null +++ b/src/otg_fs_device/doepint2/mod.rs @@ -0,0 +1,359 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPINT2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct B2BSTUPR { + bits: bool, +} +impl B2BSTUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTEPDISR { + bits: bool, +} +impl OTEPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STUPR { + bits: bool, +} +impl STUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _B2BSTUPW<'a> { + w: &'a mut W, +} +impl<'a> _B2BSTUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTEPDISW<'a> { + w: &'a mut W, +} +impl<'a> _OTEPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STUPW<'a> { + w: &'a mut W, +} +impl<'a> _STUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&self) -> B2BSTUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + B2BSTUPR { bits } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&self) -> OTEPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTEPDISR { bits } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&self) -> STUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STUPR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&mut self) -> _B2BSTUPW { + _B2BSTUPW { w: self } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&mut self) -> _OTEPDISW { + _OTEPDISW { w: self } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&mut self) -> _STUPW { + _STUPW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/doepint3/mod.rs b/src/otg_fs_device/doepint3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..767c4dc721070c2f75869a4f1f579e974a84b609 --- /dev/null +++ b/src/otg_fs_device/doepint3/mod.rs @@ -0,0 +1,359 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPINT3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct B2BSTUPR { + bits: bool, +} +impl B2BSTUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTEPDISR { + bits: bool, +} +impl OTEPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STUPR { + bits: bool, +} +impl STUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDISDR { + bits: bool, +} +impl EPDISDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _B2BSTUPW<'a> { + w: &'a mut W, +} +impl<'a> _B2BSTUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTEPDISW<'a> { + w: &'a mut W, +} +impl<'a> _OTEPDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STUPW<'a> { + w: &'a mut W, +} +impl<'a> _STUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDISDW<'a> { + w: &'a mut W, +} +impl<'a> _EPDISDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&self) -> B2BSTUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + B2BSTUPR { bits } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&self) -> OTEPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTEPDISR { bits } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&self) -> STUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STUPR { bits } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&self) -> EPDISDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISDR { bits } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 128 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - B2BSTUP"] + #[inline] + pub fn b2bstup(&mut self) -> _B2BSTUPW { + _B2BSTUPW { w: self } + } + #[doc = "Bit 4 - OTEPDIS"] + #[inline] + pub fn otepdis(&mut self) -> _OTEPDISW { + _OTEPDISW { w: self } + } + #[doc = "Bit 3 - STUP"] + #[inline] + pub fn stup(&mut self) -> _STUPW { + _STUPW { w: self } + } + #[doc = "Bit 1 - EPDISD"] + #[inline] + pub fn epdisd(&mut self) -> _EPDISDW { + _EPDISDW { w: self } + } + #[doc = "Bit 0 - XFRC"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } +} diff --git a/src/otg_fs_device/doeptsiz0/mod.rs b/src/otg_fs_device/doeptsiz0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6314fdf3ef74ddcbb6131df02176552db7295c4b --- /dev/null +++ b/src/otg_fs_device/doeptsiz0/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPTSIZ0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct STUPCNTR { + bits: u8, +} +impl STUPCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: bool, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u8, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _STUPCNTW<'a> { + w: &'a mut W, +} +impl<'a> _STUPCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - SETUP packet count"] + #[inline] + pub fn stupcnt(&self) -> STUPCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STUPCNTR { bits } + } + #[doc = "Bit 19 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:6 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - SETUP packet count"] + #[inline] + pub fn stupcnt(&mut self) -> _STUPCNTW { + _STUPCNTW { w: self } + } + #[doc = "Bit 19 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:6 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doeptsiz1/mod.rs b/src/otg_fs_device/doeptsiz1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1fab9106ae9cfc2c5fd302cd2c6f189451fd3d2e --- /dev/null +++ b/src/otg_fs_device/doeptsiz1/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPTSIZ1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RXDPID_STUPCNTR { + bits: u8, +} +impl RXDPID_STUPCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RXDPID_STUPCNTW<'a> { + w: &'a mut W, +} +impl<'a> _RXDPID_STUPCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RXDPID_STUPCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW { + _RXDPID_STUPCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doeptsiz2/mod.rs b/src/otg_fs_device/doeptsiz2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..036428acd7bacf1729b9cf2dde27cabecfd3bcd1 --- /dev/null +++ b/src/otg_fs_device/doeptsiz2/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPTSIZ2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RXDPID_STUPCNTR { + bits: u8, +} +impl RXDPID_STUPCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RXDPID_STUPCNTW<'a> { + w: &'a mut W, +} +impl<'a> _RXDPID_STUPCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RXDPID_STUPCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW { + _RXDPID_STUPCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/doeptsiz3/mod.rs b/src/otg_fs_device/doeptsiz3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1a169f08e5111cf46615cbcd7c81d8246f14cb85 --- /dev/null +++ b/src/otg_fs_device/doeptsiz3/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DOEPTSIZ3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RXDPID_STUPCNTR { + bits: u8, +} +impl RXDPID_STUPCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RXDPID_STUPCNTW<'a> { + w: &'a mut W, +} +impl<'a> _RXDPID_STUPCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&self) -> RXDPID_STUPCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RXDPID_STUPCNTR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 29:30 - Received data PID/SETUP packet count"] + #[inline] + pub fn rxdpid_stupcnt(&mut self) -> _RXDPID_STUPCNTW { + _RXDPID_STUPCNTW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } +} diff --git a/src/otg_fs_device/dtxfsts0/mod.rs b/src/otg_fs_device/dtxfsts0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..60c8f35cfd9e12794184d15b1722777845e71729 --- /dev/null +++ b/src/otg_fs_device/dtxfsts0/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DTXFSTS0 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct INEPTFSAVR { + bits: u16, +} +impl INEPTFSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"] + #[inline] + pub fn ineptfsav(&self) -> INEPTFSAVR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTFSAVR { bits } + } +} diff --git a/src/otg_fs_device/dtxfsts1/mod.rs b/src/otg_fs_device/dtxfsts1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..225b78c86ec798dc3ee80fcabecf8801809bf7e6 --- /dev/null +++ b/src/otg_fs_device/dtxfsts1/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DTXFSTS1 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct INEPTFSAVR { + bits: u16, +} +impl INEPTFSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"] + #[inline] + pub fn ineptfsav(&self) -> INEPTFSAVR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTFSAVR { bits } + } +} diff --git a/src/otg_fs_device/dtxfsts2/mod.rs b/src/otg_fs_device/dtxfsts2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..56de4f1d0fd4673db9f4d7abdf698ff4c57acd2e --- /dev/null +++ b/src/otg_fs_device/dtxfsts2/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DTXFSTS2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct INEPTFSAVR { + bits: u16, +} +impl INEPTFSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"] + #[inline] + pub fn ineptfsav(&self) -> INEPTFSAVR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTFSAVR { bits } + } +} diff --git a/src/otg_fs_device/dtxfsts3/mod.rs b/src/otg_fs_device/dtxfsts3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..77405a6baed1d499aab197b53d67a92bba77790f --- /dev/null +++ b/src/otg_fs_device/dtxfsts3/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DTXFSTS3 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct INEPTFSAVR { + bits: u16, +} +impl INEPTFSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint TxFIFO space available"] + #[inline] + pub fn ineptfsav(&self) -> INEPTFSAVR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTFSAVR { bits } + } +} diff --git a/src/otg_fs_device/dvbusdis/mod.rs b/src/otg_fs_device/dvbusdis/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f338a45fea1243645836d2b8ffc186e7d58da9ae --- /dev/null +++ b/src/otg_fs_device/dvbusdis/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DVBUSDIS { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct VBUSDTR { + bits: u16, +} +impl VBUSDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _VBUSDTW<'a> { + w: &'a mut W, +} +impl<'a> _VBUSDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Device VBUS discharge time"] + #[inline] + pub fn vbusdt(&self) -> VBUSDTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + VBUSDTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 6103 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Device VBUS discharge time"] + #[inline] + pub fn vbusdt(&mut self) -> _VBUSDTW { + _VBUSDTW { w: self } + } +} diff --git a/src/otg_fs_device/dvbuspulse/mod.rs b/src/otg_fs_device/dvbuspulse/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..83b8f4d13b02450c7d2bd886b0e7096ea3144303 --- /dev/null +++ b/src/otg_fs_device/dvbuspulse/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DVBUSPULSE { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DVBUSPR { + bits: u16, +} +impl DVBUSPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DVBUSPW<'a> { + w: &'a mut W, +} +impl<'a> _DVBUSPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:11 - Device VBUS pulsing time"] + #[inline] + pub fn dvbusp(&self) -> DVBUSPR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DVBUSPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1464 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:11 - Device VBUS pulsing time"] + #[inline] + pub fn dvbusp(&mut self) -> _DVBUSPW { + _DVBUSPW { w: self } + } +} diff --git a/src/otg_fs_device/fs_daint/mod.rs b/src/otg_fs_device/fs_daint/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6112e5cfeb5559b5c7bf4d6b181dee4d25e8f666 --- /dev/null +++ b/src/otg_fs_device/fs_daint/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_DAINT { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct IEPINTR { + bits: u16, +} +impl IEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OEPINTR { + bits: u16, +} +impl OEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint interrupt bits"] + #[inline] + pub fn iepint(&self) -> IEPINTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + IEPINTR { bits } + } + #[doc = "Bits 16:31 - OUT endpoint interrupt bits"] + #[inline] + pub fn oepint(&self) -> OEPINTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + OEPINTR { bits } + } +} diff --git a/src/otg_fs_device/fs_daintmsk/mod.rs b/src/otg_fs_device/fs_daintmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..192955b60f38e9f244ed25683aad8e48006884b2 --- /dev/null +++ b/src/otg_fs_device/fs_daintmsk/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DAINTMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IEPMR { + bits: u16, +} +impl IEPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OEPINTR { + bits: u16, +} +impl OEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IEPMW<'a> { + w: &'a mut W, +} +impl<'a> _IEPMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OEPINTW<'a> { + w: &'a mut W, +} +impl<'a> _OEPINTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN EP interrupt mask bits"] + #[inline] + pub fn iepm(&self) -> IEPMR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + IEPMR { bits } + } + #[doc = "Bits 16:31 - OUT endpoint interrupt bits"] + #[inline] + pub fn oepint(&self) -> OEPINTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + OEPINTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - IN EP interrupt mask bits"] + #[inline] + pub fn iepm(&mut self) -> _IEPMW { + _IEPMW { w: self } + } + #[doc = "Bits 16:31 - OUT endpoint interrupt bits"] + #[inline] + pub fn oepint(&mut self) -> _OEPINTW { + _OEPINTW { w: self } + } +} diff --git a/src/otg_fs_device/fs_dcfg/mod.rs b/src/otg_fs_device/fs_dcfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..084ff88a0ab4e710f8febfc3c0f330a2de163cd6 --- /dev/null +++ b/src/otg_fs_device/fs_dcfg/mod.rs @@ -0,0 +1,246 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DCFG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DSPDR { + bits: u8, +} +impl DSPDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NZLSOHSKR { + bits: bool, +} +impl NZLSOHSKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PFIVLR { + bits: u8, +} +impl PFIVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DSPDW<'a> { + w: &'a mut W, +} +impl<'a> _DSPDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NZLSOHSKW<'a> { + w: &'a mut W, +} +impl<'a> _NZLSOHSKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PFIVLW<'a> { + w: &'a mut W, +} +impl<'a> _PFIVLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - Device speed"] + #[inline] + pub fn dspd(&self) -> DSPDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DSPDR { bits } + } + #[doc = "Bit 2 - Non-zero-length status OUT handshake"] + #[inline] + pub fn nzlsohsk(&self) -> NZLSOHSKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NZLSOHSKR { bits } + } + #[doc = "Bits 4:10 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bits 11:12 - Periodic frame interval"] + #[inline] + pub fn pfivl(&self) -> PFIVLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PFIVLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 35651584 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - Device speed"] + #[inline] + pub fn dspd(&mut self) -> _DSPDW { + _DSPDW { w: self } + } + #[doc = "Bit 2 - Non-zero-length status OUT handshake"] + #[inline] + pub fn nzlsohsk(&mut self) -> _NZLSOHSKW { + _NZLSOHSKW { w: self } + } + #[doc = "Bits 4:10 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bits 11:12 - Periodic frame interval"] + #[inline] + pub fn pfivl(&mut self) -> _PFIVLW { + _PFIVLW { w: self } + } +} diff --git a/src/otg_fs_device/fs_dctl/mod.rs b/src/otg_fs_device/fs_dctl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..01d743e2275e6204ceca32386ac61bf73dab76cf --- /dev/null +++ b/src/otg_fs_device/fs_dctl/mod.rs @@ -0,0 +1,580 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DCTL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RWUSIGR { + bits: bool, +} +impl RWUSIGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDISR { + bits: bool, +} +impl SDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GINSTSR { + bits: bool, +} +impl GINSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GONSTSR { + bits: bool, +} +impl GONSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCTLR { + bits: u8, +} +impl TCTLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SGINAKR { + bits: bool, +} +impl SGINAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CGINAKR { + bits: bool, +} +impl CGINAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SGONAKR { + bits: bool, +} +impl SGONAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CGONAKR { + bits: bool, +} +impl CGONAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct POPRGDNER { + bits: bool, +} +impl POPRGDNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _RWUSIGW<'a> { + w: &'a mut W, +} +impl<'a> _RWUSIGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDISW<'a> { + w: &'a mut W, +} +impl<'a> _SDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCTLW<'a> { + w: &'a mut W, +} +impl<'a> _TCTLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SGINAKW<'a> { + w: &'a mut W, +} +impl<'a> _SGINAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CGINAKW<'a> { + w: &'a mut W, +} +impl<'a> _CGINAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SGONAKW<'a> { + w: &'a mut W, +} +impl<'a> _SGONAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CGONAKW<'a> { + w: &'a mut W, +} +impl<'a> _CGONAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _POPRGDNEW<'a> { + w: &'a mut W, +} +impl<'a> _POPRGDNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Remote wakeup signaling"] + #[inline] + pub fn rwusig(&self) -> RWUSIGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RWUSIGR { bits } + } + #[doc = "Bit 1 - Soft disconnect"] + #[inline] + pub fn sdis(&self) -> SDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDISR { bits } + } + #[doc = "Bit 2 - Global IN NAK status"] + #[inline] + pub fn ginsts(&self) -> GINSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GINSTSR { bits } + } + #[doc = "Bit 3 - Global OUT NAK status"] + #[inline] + pub fn gonsts(&self) -> GONSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GONSTSR { bits } + } + #[doc = "Bits 4:6 - Test control"] + #[inline] + pub fn tctl(&self) -> TCTLR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TCTLR { bits } + } + #[doc = "Bit 7 - Set global IN NAK"] + #[inline] + pub fn sginak(&self) -> SGINAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SGINAKR { bits } + } + #[doc = "Bit 8 - Clear global IN NAK"] + #[inline] + pub fn cginak(&self) -> CGINAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CGINAKR { bits } + } + #[doc = "Bit 9 - Set global OUT NAK"] + #[inline] + pub fn sgonak(&self) -> SGONAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SGONAKR { bits } + } + #[doc = "Bit 10 - Clear global OUT NAK"] + #[inline] + pub fn cgonak(&self) -> CGONAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CGONAKR { bits } + } + #[doc = "Bit 11 - Power-on programming done"] + #[inline] + pub fn poprgdne(&self) -> POPRGDNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + POPRGDNER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Remote wakeup signaling"] + #[inline] + pub fn rwusig(&mut self) -> _RWUSIGW { + _RWUSIGW { w: self } + } + #[doc = "Bit 1 - Soft disconnect"] + #[inline] + pub fn sdis(&mut self) -> _SDISW { + _SDISW { w: self } + } + #[doc = "Bits 4:6 - Test control"] + #[inline] + pub fn tctl(&mut self) -> _TCTLW { + _TCTLW { w: self } + } + #[doc = "Bit 7 - Set global IN NAK"] + #[inline] + pub fn sginak(&mut self) -> _SGINAKW { + _SGINAKW { w: self } + } + #[doc = "Bit 8 - Clear global IN NAK"] + #[inline] + pub fn cginak(&mut self) -> _CGINAKW { + _CGINAKW { w: self } + } + #[doc = "Bit 9 - Set global OUT NAK"] + #[inline] + pub fn sgonak(&mut self) -> _SGONAKW { + _SGONAKW { w: self } + } + #[doc = "Bit 10 - Clear global OUT NAK"] + #[inline] + pub fn cgonak(&mut self) -> _CGONAKW { + _CGONAKW { w: self } + } + #[doc = "Bit 11 - Power-on programming done"] + #[inline] + pub fn poprgdne(&mut self) -> _POPRGDNEW { + _POPRGDNEW { w: self } + } +} diff --git a/src/otg_fs_device/fs_diepctl0/mod.rs b/src/otg_fs_device/fs_diepctl0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..96887c54c6ae7b444657598aa6fff48d08e3e7f0 --- /dev/null +++ b/src/otg_fs_device/fs_diepctl0/mod.rs @@ -0,0 +1,406 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DIEPCTL0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u8, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct USBAEPR { + bits: bool, +} +impl USBAEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKSTSR { + bits: bool, +} +impl NAKSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFNUMR { + bits: u8, +} +impl TXFNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDISR { + bits: bool, +} +impl EPDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPENAR { + bits: bool, +} +impl EPENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFNUMW<'a> { + w: &'a mut W, +} +impl<'a> _TXFNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNAKW<'a> { + w: &'a mut W, +} +impl<'a> _CNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SNAKW<'a> { + w: &'a mut W, +} +impl<'a> _SNAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MPSIZR { bits } + } + #[doc = "Bit 15 - USB active endpoint"] + #[inline] + pub fn usbaep(&self) -> USBAEPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBAEPR { bits } + } + #[doc = "Bit 17 - NAK status"] + #[inline] + pub fn naksts(&self) -> NAKSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKSTSR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bit 21 - STALL handshake"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bits 22:25 - TxFIFO number"] + #[inline] + pub fn txfnum(&self) -> TXFNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXFNUMR { bits } + } + #[doc = "Bit 30 - Endpoint disable"] + #[inline] + pub fn epdis(&self) -> EPDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDISR { bits } + } + #[doc = "Bit 31 - Endpoint enable"] + #[inline] + pub fn epena(&self) -> EPENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bit 21 - STALL handshake"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bits 22:25 - TxFIFO number"] + #[inline] + pub fn txfnum(&mut self) -> _TXFNUMW { + _TXFNUMW { w: self } + } + #[doc = "Bit 26 - Clear NAK"] + #[inline] + pub fn cnak(&mut self) -> _CNAKW { + _CNAKW { w: self } + } + #[doc = "Bit 27 - Set NAK"] + #[inline] + pub fn snak(&mut self) -> _SNAKW { + _SNAKW { w: self } + } +} diff --git a/src/otg_fs_device/fs_diepmsk/mod.rs b/src/otg_fs_device/fs_diepmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9b613938cd716b40db4ae40fe8968f8fa9e39cba --- /dev/null +++ b/src/otg_fs_device/fs_diepmsk/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DIEPMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDMR { + bits: bool, +} +impl EPDMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOMR { + bits: bool, +} +impl TOMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ITTXFEMSKR { + bits: bool, +} +impl ITTXFEMSKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNMMR { + bits: bool, +} +impl INEPNMMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INEPNEMR { + bits: bool, +} +impl INEPNEMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDMW<'a> { + w: &'a mut W, +} +impl<'a> _EPDMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOMW<'a> { + w: &'a mut W, +} +impl<'a> _TOMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ITTXFEMSKW<'a> { + w: &'a mut W, +} +impl<'a> _ITTXFEMSKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INEPNMMW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNMMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INEPNEMW<'a> { + w: &'a mut W, +} +impl<'a> _INEPNEMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed interrupt mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Endpoint disabled interrupt mask"] + #[inline] + pub fn epdm(&self) -> EPDMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDMR { bits } + } + #[doc = "Bit 3 - Timeout condition mask (Non-isochronous endpoints)"] + #[inline] + pub fn tom(&self) -> TOMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOMR { bits } + } + #[doc = "Bit 4 - IN token received when TxFIFO empty mask"] + #[inline] + pub fn ittxfemsk(&self) -> ITTXFEMSKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ITTXFEMSKR { bits } + } + #[doc = "Bit 5 - IN token received with EP mismatch mask"] + #[inline] + pub fn inepnmm(&self) -> INEPNMMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNMMR { bits } + } + #[doc = "Bit 6 - IN endpoint NAK effective mask"] + #[inline] + pub fn inepnem(&self) -> INEPNEMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INEPNEMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed interrupt mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Endpoint disabled interrupt mask"] + #[inline] + pub fn epdm(&mut self) -> _EPDMW { + _EPDMW { w: self } + } + #[doc = "Bit 3 - Timeout condition mask (Non-isochronous endpoints)"] + #[inline] + pub fn tom(&mut self) -> _TOMW { + _TOMW { w: self } + } + #[doc = "Bit 4 - IN token received when TxFIFO empty mask"] + #[inline] + pub fn ittxfemsk(&mut self) -> _ITTXFEMSKW { + _ITTXFEMSKW { w: self } + } + #[doc = "Bit 5 - IN token received with EP mismatch mask"] + #[inline] + pub fn inepnmm(&mut self) -> _INEPNMMW { + _INEPNMMW { w: self } + } + #[doc = "Bit 6 - IN endpoint NAK effective mask"] + #[inline] + pub fn inepnem(&mut self) -> _INEPNEMW { + _INEPNEMW { w: self } + } +} diff --git a/src/otg_fs_device/fs_doepmsk/mod.rs b/src/otg_fs_device/fs_doepmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9b48cd0992570d31d798d1250048c2c8465cea62 --- /dev/null +++ b/src/otg_fs_device/fs_doepmsk/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DOEPMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPDMR { + bits: bool, +} +impl EPDMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STUPMR { + bits: bool, +} +impl STUPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTEPDMR { + bits: bool, +} +impl OTEPDMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDMW<'a> { + w: &'a mut W, +} +impl<'a> _EPDMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STUPMW<'a> { + w: &'a mut W, +} +impl<'a> _STUPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTEPDMW<'a> { + w: &'a mut W, +} +impl<'a> _OTEPDMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed interrupt mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Endpoint disabled interrupt mask"] + #[inline] + pub fn epdm(&self) -> EPDMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDMR { bits } + } + #[doc = "Bit 3 - SETUP phase done mask"] + #[inline] + pub fn stupm(&self) -> STUPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STUPMR { bits } + } + #[doc = "Bit 4 - OUT token received when endpoint disabled mask"] + #[inline] + pub fn otepdm(&self) -> OTEPDMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTEPDMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed interrupt mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Endpoint disabled interrupt mask"] + #[inline] + pub fn epdm(&mut self) -> _EPDMW { + _EPDMW { w: self } + } + #[doc = "Bit 3 - SETUP phase done mask"] + #[inline] + pub fn stupm(&mut self) -> _STUPMW { + _STUPMW { w: self } + } + #[doc = "Bit 4 - OUT token received when endpoint disabled mask"] + #[inline] + pub fn otepdm(&mut self) -> _OTEPDMW { + _OTEPDMW { w: self } + } +} diff --git a/src/otg_fs_device/fs_dsts/mod.rs b/src/otg_fs_device/fs_dsts/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f7993886a0439095c4a18b37f716e04acc2bf7e0 --- /dev/null +++ b/src/otg_fs_device/fs_dsts/mod.rs @@ -0,0 +1,145 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_DSTS { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SUSPSTSR { + bits: bool, +} +impl SUSPSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENUMSPDR { + bits: u8, +} +impl ENUMSPDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EERRR { + bits: bool, +} +impl EERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FNSOFR { + bits: u16, +} +impl FNSOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DEVLNSTSR { + bits: u8, +} +impl DEVLNSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Suspend status"] + #[inline] + pub fn suspsts(&self) -> SUSPSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SUSPSTSR { bits } + } + #[doc = "Bits 1:2 - Enumerated speed"] + #[inline] + pub fn enumspd(&self) -> ENUMSPDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ENUMSPDR { bits } + } + #[doc = "Bit 3 - Erratic error"] + #[inline] + pub fn eerr(&self) -> EERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EERRR { bits } + } + #[doc = "Bits 8:21 - Frame number of the received SOF"] + #[inline] + pub fn fnsof(&self) -> FNSOFR { + let bits = { + const MASK: u16 = 16383; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FNSOFR { bits } + } + #[doc = "Bits 22:23 - Device line status"] + #[inline] + pub fn devlnsts(&self) -> DEVLNSTSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DEVLNSTSR { bits } + } +} diff --git a/src/otg_fs_device/mod.rs b/src/otg_fs_device/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bcd5be36a34eacaf13b9e2a3fd69b8a190eb517c --- /dev/null +++ b/src/otg_fs_device/mod.rs @@ -0,0 +1,339 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - OTG_FS device configuration register (OTG_FS_DCFG)"] + pub fs_dcfg: FS_DCFG, + #[doc = "0x04 - OTG_FS device control register (OTG_FS_DCTL)"] + pub fs_dctl: FS_DCTL, + #[doc = "0x08 - OTG_FS device status register (OTG_FS_DSTS)"] + pub fs_dsts: FS_DSTS, + _reserved0: [u8; 4usize], + #[doc = "0x10 - OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"] + pub fs_diepmsk: FS_DIEPMSK, + #[doc = "0x14 - OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"] + pub fs_doepmsk: FS_DOEPMSK, + #[doc = "0x18 - OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"] + pub fs_daint: FS_DAINT, + #[doc = "0x1c - OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"] + pub fs_daintmsk: FS_DAINTMSK, + _reserved1: [u8; 8usize], + #[doc = "0x28 - OTG_FS device VBUS discharge time register"] + pub dvbusdis: DVBUSDIS, + #[doc = "0x2c - OTG_FS device VBUS pulsing time register"] + pub dvbuspulse: DVBUSPULSE, + _reserved2: [u8; 4usize], + #[doc = "0x34 - OTG_FS device IN endpoint FIFO empty interrupt mask register"] + pub diepempmsk: DIEPEMPMSK, + _reserved3: [u8; 200usize], + #[doc = "0x100 - OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"] + pub fs_diepctl0: FS_DIEPCTL0, + _reserved4: [u8; 4usize], + #[doc = "0x108 - device endpoint-x interrupt register"] + pub diepint0: DIEPINT0, + _reserved5: [u8; 4usize], + #[doc = "0x110 - device endpoint-0 transfer size register"] + pub dieptsiz0: DIEPTSIZ0, + _reserved6: [u8; 4usize], + #[doc = "0x118 - OTG_FS device IN endpoint transmit FIFO status register"] + pub dtxfsts0: DTXFSTS0, + _reserved7: [u8; 4usize], + #[doc = "0x120 - OTG device endpoint-1 control register"] + pub diepctl1: DIEPCTL1, + _reserved8: [u8; 4usize], + #[doc = "0x128 - device endpoint-1 interrupt register"] + pub diepint1: DIEPINT1, + _reserved9: [u8; 4usize], + #[doc = "0x130 - device endpoint-1 transfer size register"] + pub dieptsiz1: DIEPTSIZ1, + _reserved10: [u8; 4usize], + #[doc = "0x138 - OTG_FS device IN endpoint transmit FIFO status register"] + pub dtxfsts1: DTXFSTS1, + _reserved11: [u8; 4usize], + #[doc = "0x140 - OTG device endpoint-2 control register"] + pub diepctl2: DIEPCTL2, + _reserved12: [u8; 4usize], + #[doc = "0x148 - device endpoint-2 interrupt register"] + pub diepint2: DIEPINT2, + _reserved13: [u8; 4usize], + #[doc = "0x150 - device endpoint-2 transfer size register"] + pub dieptsiz2: DIEPTSIZ2, + _reserved14: [u8; 4usize], + #[doc = "0x158 - OTG_FS device IN endpoint transmit FIFO status register"] + pub dtxfsts2: DTXFSTS2, + _reserved15: [u8; 4usize], + #[doc = "0x160 - OTG device endpoint-3 control register"] + pub diepctl3: DIEPCTL3, + _reserved16: [u8; 4usize], + #[doc = "0x168 - device endpoint-3 interrupt register"] + pub diepint3: DIEPINT3, + _reserved17: [u8; 4usize], + #[doc = "0x170 - device endpoint-3 transfer size register"] + pub dieptsiz3: DIEPTSIZ3, + _reserved18: [u8; 4usize], + #[doc = "0x178 - OTG_FS device IN endpoint transmit FIFO status register"] + pub dtxfsts3: DTXFSTS3, + _reserved19: [u8; 388usize], + #[doc = "0x300 - device endpoint-0 control register"] + pub doepctl0: DOEPCTL0, + _reserved20: [u8; 4usize], + #[doc = "0x308 - device endpoint-0 interrupt register"] + pub doepint0: DOEPINT0, + _reserved21: [u8; 4usize], + #[doc = "0x310 - device OUT endpoint-0 transfer size register"] + pub doeptsiz0: DOEPTSIZ0, + _reserved22: [u8; 12usize], + #[doc = "0x320 - device endpoint-1 control register"] + pub doepctl1: DOEPCTL1, + _reserved23: [u8; 4usize], + #[doc = "0x328 - device endpoint-1 interrupt register"] + pub doepint1: DOEPINT1, + _reserved24: [u8; 4usize], + #[doc = "0x330 - device OUT endpoint-1 transfer size register"] + pub doeptsiz1: DOEPTSIZ1, + _reserved25: [u8; 12usize], + #[doc = "0x340 - device endpoint-2 control register"] + pub doepctl2: DOEPCTL2, + _reserved26: [u8; 4usize], + #[doc = "0x348 - device endpoint-2 interrupt register"] + pub doepint2: DOEPINT2, + _reserved27: [u8; 4usize], + #[doc = "0x350 - device OUT endpoint-2 transfer size register"] + pub doeptsiz2: DOEPTSIZ2, + _reserved28: [u8; 12usize], + #[doc = "0x360 - device endpoint-3 control register"] + pub doepctl3: DOEPCTL3, + _reserved29: [u8; 4usize], + #[doc = "0x368 - device endpoint-3 interrupt register"] + pub doepint3: DOEPINT3, + _reserved30: [u8; 4usize], + #[doc = "0x370 - device OUT endpoint-3 transfer size register"] + pub doeptsiz3: DOEPTSIZ3, +} +#[doc = "OTG_FS device configuration register (OTG_FS_DCFG)"] +pub struct FS_DCFG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device configuration register (OTG_FS_DCFG)"] +pub mod fs_dcfg; +#[doc = "OTG_FS device control register (OTG_FS_DCTL)"] +pub struct FS_DCTL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device control register (OTG_FS_DCTL)"] +pub mod fs_dctl; +#[doc = "OTG_FS device status register (OTG_FS_DSTS)"] +pub struct FS_DSTS { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device status register (OTG_FS_DSTS)"] +pub mod fs_dsts; +#[doc = "OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"] +pub struct FS_DIEPMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint common interrupt mask register (OTG_FS_DIEPMSK)"] +pub mod fs_diepmsk; +#[doc = "OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"] +pub struct FS_DOEPMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device OUT endpoint common interrupt mask register (OTG_FS_DOEPMSK)"] +pub mod fs_doepmsk; +#[doc = "OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"] +pub struct FS_DAINT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device all endpoints interrupt register (OTG_FS_DAINT)"] +pub mod fs_daint; +#[doc = "OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"] +pub struct FS_DAINTMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS all endpoints interrupt mask register (OTG_FS_DAINTMSK)"] +pub mod fs_daintmsk; +#[doc = "OTG_FS device VBUS discharge time register"] +pub struct DVBUSDIS { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device VBUS discharge time register"] +pub mod dvbusdis; +#[doc = "OTG_FS device VBUS pulsing time register"] +pub struct DVBUSPULSE { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device VBUS pulsing time register"] +pub mod dvbuspulse; +#[doc = "OTG_FS device IN endpoint FIFO empty interrupt mask register"] +pub struct DIEPEMPMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint FIFO empty interrupt mask register"] +pub mod diepempmsk; +#[doc = "OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"] +pub struct FS_DIEPCTL0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device control IN endpoint 0 control register (OTG_FS_DIEPCTL0)"] +pub mod fs_diepctl0; +#[doc = "OTG device endpoint-1 control register"] +pub struct DIEPCTL1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG device endpoint-1 control register"] +pub mod diepctl1; +#[doc = "OTG device endpoint-2 control register"] +pub struct DIEPCTL2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG device endpoint-2 control register"] +pub mod diepctl2; +#[doc = "OTG device endpoint-3 control register"] +pub struct DIEPCTL3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG device endpoint-3 control register"] +pub mod diepctl3; +#[doc = "device endpoint-0 control register"] +pub struct DOEPCTL0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-0 control register"] +pub mod doepctl0; +#[doc = "device endpoint-1 control register"] +pub struct DOEPCTL1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-1 control register"] +pub mod doepctl1; +#[doc = "device endpoint-2 control register"] +pub struct DOEPCTL2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-2 control register"] +pub mod doepctl2; +#[doc = "device endpoint-3 control register"] +pub struct DOEPCTL3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-3 control register"] +pub mod doepctl3; +#[doc = "device endpoint-x interrupt register"] +pub struct DIEPINT0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-x interrupt register"] +pub mod diepint0; +#[doc = "device endpoint-1 interrupt register"] +pub struct DIEPINT1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-1 interrupt register"] +pub mod diepint1; +#[doc = "device endpoint-2 interrupt register"] +pub struct DIEPINT2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-2 interrupt register"] +pub mod diepint2; +#[doc = "device endpoint-3 interrupt register"] +pub struct DIEPINT3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-3 interrupt register"] +pub mod diepint3; +#[doc = "device endpoint-0 interrupt register"] +pub struct DOEPINT0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-0 interrupt register"] +pub mod doepint0; +#[doc = "device endpoint-1 interrupt register"] +pub struct DOEPINT1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-1 interrupt register"] +pub mod doepint1; +#[doc = "device endpoint-2 interrupt register"] +pub struct DOEPINT2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-2 interrupt register"] +pub mod doepint2; +#[doc = "device endpoint-3 interrupt register"] +pub struct DOEPINT3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-3 interrupt register"] +pub mod doepint3; +#[doc = "device endpoint-0 transfer size register"] +pub struct DIEPTSIZ0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-0 transfer size register"] +pub mod dieptsiz0; +#[doc = "device OUT endpoint-0 transfer size register"] +pub struct DOEPTSIZ0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device OUT endpoint-0 transfer size register"] +pub mod doeptsiz0; +#[doc = "device endpoint-1 transfer size register"] +pub struct DIEPTSIZ1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-1 transfer size register"] +pub mod dieptsiz1; +#[doc = "device endpoint-2 transfer size register"] +pub struct DIEPTSIZ2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-2 transfer size register"] +pub mod dieptsiz2; +#[doc = "device endpoint-3 transfer size register"] +pub struct DIEPTSIZ3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device endpoint-3 transfer size register"] +pub mod dieptsiz3; +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub struct DTXFSTS0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub mod dtxfsts0; +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub struct DTXFSTS1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub mod dtxfsts1; +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub struct DTXFSTS2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub mod dtxfsts2; +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub struct DTXFSTS3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO status register"] +pub mod dtxfsts3; +#[doc = "device OUT endpoint-1 transfer size register"] +pub struct DOEPTSIZ1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device OUT endpoint-1 transfer size register"] +pub mod doeptsiz1; +#[doc = "device OUT endpoint-2 transfer size register"] +pub struct DOEPTSIZ2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device OUT endpoint-2 transfer size register"] +pub mod doeptsiz2; +#[doc = "device OUT endpoint-3 transfer size register"] +pub struct DOEPTSIZ3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device OUT endpoint-3 transfer size register"] +pub mod doeptsiz3; diff --git a/src/otg_fs_global/fs_cid/mod.rs b/src/otg_fs_global/fs_cid/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..72d1fd6f260fb97d1799ab57466f05368bb890c5 --- /dev/null +++ b/src/otg_fs_global/fs_cid/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_CID { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PRODUCT_IDR { + bits: u32, +} +impl PRODUCT_IDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PRODUCT_IDW<'a> { + w: &'a mut W, +} +impl<'a> _PRODUCT_IDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Product ID field"] + #[inline] + pub fn product_id(&self) -> PRODUCT_IDR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + PRODUCT_IDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 4096 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Product ID field"] + #[inline] + pub fn product_id(&mut self) -> _PRODUCT_IDW { + _PRODUCT_IDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_dieptxf1/mod.rs b/src/otg_fs_global/fs_dieptxf1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..005b52d31f729db51420c3358d995c1cdc1157d3 --- /dev/null +++ b/src/otg_fs_global/fs_dieptxf1/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DIEPTXF1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INEPTXSAR { + bits: u16, +} +impl INEPTXSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INEPTXFDR { + bits: u16, +} +impl INEPTXFDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INEPTXSAW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INEPTXFDW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXFDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint FIFO2 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&self) -> INEPTXSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXSAR { bits } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&self) -> INEPTXFDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXFDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33555456 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - IN endpoint FIFO2 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&mut self) -> _INEPTXSAW { + _INEPTXSAW { w: self } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&mut self) -> _INEPTXFDW { + _INEPTXFDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_dieptxf2/mod.rs b/src/otg_fs_global/fs_dieptxf2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2e95dccd6ed5cd58538f0a6aafd42b18f8f9613d --- /dev/null +++ b/src/otg_fs_global/fs_dieptxf2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DIEPTXF2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INEPTXSAR { + bits: u16, +} +impl INEPTXSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INEPTXFDR { + bits: u16, +} +impl INEPTXFDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INEPTXSAW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INEPTXFDW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXFDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint FIFO3 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&self) -> INEPTXSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXSAR { bits } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&self) -> INEPTXFDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXFDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33555456 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - IN endpoint FIFO3 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&mut self) -> _INEPTXSAW { + _INEPTXSAW { w: self } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&mut self) -> _INEPTXFDW { + _INEPTXFDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_dieptxf3/mod.rs b/src/otg_fs_global/fs_dieptxf3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8716e3be435e5ee1246ec7ac22e5feb64aa70fc4 --- /dev/null +++ b/src/otg_fs_global/fs_dieptxf3/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_DIEPTXF3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INEPTXSAR { + bits: u16, +} +impl INEPTXSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INEPTXFDR { + bits: u16, +} +impl INEPTXFDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INEPTXSAW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INEPTXFDW<'a> { + w: &'a mut W, +} +impl<'a> _INEPTXFDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - IN endpoint FIFO4 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&self) -> INEPTXSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXSAR { bits } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&self) -> INEPTXFDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INEPTXFDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33555456 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - IN endpoint FIFO4 transmit RAM start address"] + #[inline] + pub fn ineptxsa(&mut self) -> _INEPTXSAW { + _INEPTXSAW { w: self } + } + #[doc = "Bits 16:31 - IN endpoint TxFIFO depth"] + #[inline] + pub fn ineptxfd(&mut self) -> _INEPTXFDW { + _INEPTXFDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gahbcfg/mod.rs b/src/otg_fs_global/fs_gahbcfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..14b89039d39fa2c7312c13981b013382ac9501f2 --- /dev/null +++ b/src/otg_fs_global/fs_gahbcfg/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GAHBCFG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct GINTR { + bits: bool, +} +impl GINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFELVLR { + bits: bool, +} +impl TXFELVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PTXFELVLR { + bits: bool, +} +impl PTXFELVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _GINTW<'a> { + w: &'a mut W, +} +impl<'a> _GINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFELVLW<'a> { + w: &'a mut W, +} +impl<'a> _TXFELVLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTXFELVLW<'a> { + w: &'a mut W, +} +impl<'a> _PTXFELVLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Global interrupt mask"] + #[inline] + pub fn gint(&self) -> GINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GINTR { bits } + } + #[doc = "Bit 7 - TxFIFO empty level"] + #[inline] + pub fn txfelvl(&self) -> TXFELVLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFELVLR { bits } + } + #[doc = "Bit 8 - Periodic TxFIFO empty level"] + #[inline] + pub fn ptxfelvl(&self) -> PTXFELVLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTXFELVLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Global interrupt mask"] + #[inline] + pub fn gint(&mut self) -> _GINTW { + _GINTW { w: self } + } + #[doc = "Bit 7 - TxFIFO empty level"] + #[inline] + pub fn txfelvl(&mut self) -> _TXFELVLW { + _TXFELVLW { w: self } + } + #[doc = "Bit 8 - Periodic TxFIFO empty level"] + #[inline] + pub fn ptxfelvl(&mut self) -> _PTXFELVLW { + _PTXFELVLW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gccfg/mod.rs b/src/otg_fs_global/fs_gccfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bf4b7339ff09d323fa3b6a971f685c908a1c112d --- /dev/null +++ b/src/otg_fs_global/fs_gccfg/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GCCFG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DCDETR { + bits: bool, +} +impl DCDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PDETR { + bits: bool, +} +impl PDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDETR { + bits: bool, +} +impl SDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PS2DETR { + bits: bool, +} +impl PS2DETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWRDWNR { + bits: bool, +} +impl PWRDWNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BCDENR { + bits: bool, +} +impl BCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCDENR { + bits: bool, +} +impl DCDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PDENR { + bits: bool, +} +impl PDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDENR { + bits: bool, +} +impl SDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct VBDENR { + bits: bool, +} +impl VBDENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _DCDETW<'a> { + w: &'a mut W, +} +impl<'a> _DCDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PDETW<'a> { + w: &'a mut W, +} +impl<'a> _PDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDETW<'a> { + w: &'a mut W, +} +impl<'a> _SDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PS2DETW<'a> { + w: &'a mut W, +} +impl<'a> _PS2DETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWRDWNW<'a> { + w: &'a mut W, +} +impl<'a> _PWRDWNW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BCDENW<'a> { + w: &'a mut W, +} +impl<'a> _BCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCDENW<'a> { + w: &'a mut W, +} +impl<'a> _DCDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PDENW<'a> { + w: &'a mut W, +} +impl<'a> _PDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDENW<'a> { + w: &'a mut W, +} +impl<'a> _SDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _VBDENW<'a> { + w: &'a mut W, +} +impl<'a> _VBDENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - DCDET"] + #[inline] + pub fn dcdet(&self) -> DCDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCDETR { bits } + } + #[doc = "Bit 1 - PDET"] + #[inline] + pub fn pdet(&self) -> PDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PDETR { bits } + } + #[doc = "Bit 2 - SDET"] + #[inline] + pub fn sdet(&self) -> SDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDETR { bits } + } + #[doc = "Bit 3 - PS2DET"] + #[inline] + pub fn ps2det(&self) -> PS2DETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PS2DETR { bits } + } + #[doc = "Bit 16 - PWRDWN"] + #[inline] + pub fn pwrdwn(&self) -> PWRDWNR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWRDWNR { bits } + } + #[doc = "Bit 17 - BCDEN"] + #[inline] + pub fn bcden(&self) -> BCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BCDENR { bits } + } + #[doc = "Bit 18 - DCDEN"] + #[inline] + pub fn dcden(&self) -> DCDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCDENR { bits } + } + #[doc = "Bit 19 - PDEN"] + #[inline] + pub fn pden(&self) -> PDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PDENR { bits } + } + #[doc = "Bit 20 - SDEN"] + #[inline] + pub fn sden(&self) -> SDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDENR { bits } + } + #[doc = "Bit 21 - VBDEN"] + #[inline] + pub fn vbden(&self) -> VBDENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + VBDENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - DCDET"] + #[inline] + pub fn dcdet(&mut self) -> _DCDETW { + _DCDETW { w: self } + } + #[doc = "Bit 1 - PDET"] + #[inline] + pub fn pdet(&mut self) -> _PDETW { + _PDETW { w: self } + } + #[doc = "Bit 2 - SDET"] + #[inline] + pub fn sdet(&mut self) -> _SDETW { + _SDETW { w: self } + } + #[doc = "Bit 3 - PS2DET"] + #[inline] + pub fn ps2det(&mut self) -> _PS2DETW { + _PS2DETW { w: self } + } + #[doc = "Bit 16 - PWRDWN"] + #[inline] + pub fn pwrdwn(&mut self) -> _PWRDWNW { + _PWRDWNW { w: self } + } + #[doc = "Bit 17 - BCDEN"] + #[inline] + pub fn bcden(&mut self) -> _BCDENW { + _BCDENW { w: self } + } + #[doc = "Bit 18 - DCDEN"] + #[inline] + pub fn dcden(&mut self) -> _DCDENW { + _DCDENW { w: self } + } + #[doc = "Bit 19 - PDEN"] + #[inline] + pub fn pden(&mut self) -> _PDENW { + _PDENW { w: self } + } + #[doc = "Bit 20 - SDEN"] + #[inline] + pub fn sden(&mut self) -> _SDENW { + _SDENW { w: self } + } + #[doc = "Bit 21 - VBDEN"] + #[inline] + pub fn vbden(&mut self) -> _VBDENW { + _VBDENW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gintmsk/mod.rs b/src/otg_fs_global/fs_gintmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..350e54df89245cd481b506aa08c1afea0a35ab0a --- /dev/null +++ b/src/otg_fs_global/fs_gintmsk/mod.rs @@ -0,0 +1,1511 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GINTMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MMISMR { + bits: bool, +} +impl MMISMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTGINTR { + bits: bool, +} +impl OTGINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SOFMR { + bits: bool, +} +impl SOFMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFLVLMR { + bits: bool, +} +impl RXFLVLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NPTXFEMR { + bits: bool, +} +impl NPTXFEMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GINAKEFFMR { + bits: bool, +} +impl GINAKEFFMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GONAKEFFMR { + bits: bool, +} +impl GONAKEFFMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ESUSPMR { + bits: bool, +} +impl ESUSPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBSUSPMR { + bits: bool, +} +impl USBSUSPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBRSTR { + bits: bool, +} +impl USBRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENUMDNEMR { + bits: bool, +} +impl ENUMDNEMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ISOODRPMR { + bits: bool, +} +impl ISOODRPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOPFMR { + bits: bool, +} +impl EOPFMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPMISMR { + bits: bool, +} +impl EPMISMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IEPINTR { + bits: bool, +} +impl IEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OEPINTR { + bits: bool, +} +impl OEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IISOIXFRMR { + bits: bool, +} +impl IISOIXFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IPXFRM_IISOOXFRMR { + bits: bool, +} +impl IPXFRM_IISOOXFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PRTIMR { + bits: bool, +} +impl PRTIMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HCIMR { + bits: bool, +} +impl HCIMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PTXFEMR { + bits: bool, +} +impl PTXFEMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIDSCHGMR { + bits: bool, +} +impl CIDSCHGMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DISCINTR { + bits: bool, +} +impl DISCINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRQIMR { + bits: bool, +} +impl SRQIMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WUIMR { + bits: bool, +} +impl WUIMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MMISMW<'a> { + w: &'a mut W, +} +impl<'a> _MMISMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OTGINTW<'a> { + w: &'a mut W, +} +impl<'a> _OTGINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SOFMW<'a> { + w: &'a mut W, +} +impl<'a> _SOFMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXFLVLMW<'a> { + w: &'a mut W, +} +impl<'a> _RXFLVLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NPTXFEMW<'a> { + w: &'a mut W, +} +impl<'a> _NPTXFEMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GINAKEFFMW<'a> { + w: &'a mut W, +} +impl<'a> _GINAKEFFMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GONAKEFFMW<'a> { + w: &'a mut W, +} +impl<'a> _GONAKEFFMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ESUSPMW<'a> { + w: &'a mut W, +} +impl<'a> _ESUSPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBSUSPMW<'a> { + w: &'a mut W, +} +impl<'a> _USBSUSPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBRSTW<'a> { + w: &'a mut W, +} +impl<'a> _USBRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENUMDNEMW<'a> { + w: &'a mut W, +} +impl<'a> _ENUMDNEMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ISOODRPMW<'a> { + w: &'a mut W, +} +impl<'a> _ISOODRPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOPFMW<'a> { + w: &'a mut W, +} +impl<'a> _EOPFMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPMISMW<'a> { + w: &'a mut W, +} +impl<'a> _EPMISMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IEPINTW<'a> { + w: &'a mut W, +} +impl<'a> _IEPINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OEPINTW<'a> { + w: &'a mut W, +} +impl<'a> _OEPINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IISOIXFRMW<'a> { + w: &'a mut W, +} +impl<'a> _IISOIXFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IPXFRM_IISOOXFRMW<'a> { + w: &'a mut W, +} +impl<'a> _IPXFRM_IISOOXFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HCIMW<'a> { + w: &'a mut W, +} +impl<'a> _HCIMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTXFEMW<'a> { + w: &'a mut W, +} +impl<'a> _PTXFEMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIDSCHGMW<'a> { + w: &'a mut W, +} +impl<'a> _CIDSCHGMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DISCINTW<'a> { + w: &'a mut W, +} +impl<'a> _DISCINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRQIMW<'a> { + w: &'a mut W, +} +impl<'a> _SRQIMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WUIMW<'a> { + w: &'a mut W, +} +impl<'a> _WUIMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 1 - Mode mismatch interrupt mask"] + #[inline] + pub fn mmism(&self) -> MMISMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MMISMR { bits } + } + #[doc = "Bit 2 - OTG interrupt mask"] + #[inline] + pub fn otgint(&self) -> OTGINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTGINTR { bits } + } + #[doc = "Bit 3 - Start of frame mask"] + #[inline] + pub fn sofm(&self) -> SOFMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SOFMR { bits } + } + #[doc = "Bit 4 - Receive FIFO non-empty mask"] + #[inline] + pub fn rxflvlm(&self) -> RXFLVLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFLVLMR { bits } + } + #[doc = "Bit 5 - Non-periodic TxFIFO empty mask"] + #[inline] + pub fn nptxfem(&self) -> NPTXFEMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NPTXFEMR { bits } + } + #[doc = "Bit 6 - Global non-periodic IN NAK effective mask"] + #[inline] + pub fn ginakeffm(&self) -> GINAKEFFMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GINAKEFFMR { bits } + } + #[doc = "Bit 7 - Global OUT NAK effective mask"] + #[inline] + pub fn gonakeffm(&self) -> GONAKEFFMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GONAKEFFMR { bits } + } + #[doc = "Bit 10 - Early suspend mask"] + #[inline] + pub fn esuspm(&self) -> ESUSPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ESUSPMR { bits } + } + #[doc = "Bit 11 - USB suspend mask"] + #[inline] + pub fn usbsuspm(&self) -> USBSUSPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBSUSPMR { bits } + } + #[doc = "Bit 12 - USB reset mask"] + #[inline] + pub fn usbrst(&self) -> USBRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBRSTR { bits } + } + #[doc = "Bit 13 - Enumeration done mask"] + #[inline] + pub fn enumdnem(&self) -> ENUMDNEMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENUMDNEMR { bits } + } + #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt mask"] + #[inline] + pub fn isoodrpm(&self) -> ISOODRPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ISOODRPMR { bits } + } + #[doc = "Bit 15 - End of periodic frame interrupt mask"] + #[inline] + pub fn eopfm(&self) -> EOPFMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOPFMR { bits } + } + #[doc = "Bit 17 - Endpoint mismatch interrupt mask"] + #[inline] + pub fn epmism(&self) -> EPMISMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPMISMR { bits } + } + #[doc = "Bit 18 - IN endpoints interrupt mask"] + #[inline] + pub fn iepint(&self) -> IEPINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IEPINTR { bits } + } + #[doc = "Bit 19 - OUT endpoints interrupt mask"] + #[inline] + pub fn oepint(&self) -> OEPINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OEPINTR { bits } + } + #[doc = "Bit 20 - Incomplete isochronous IN transfer mask"] + #[inline] + pub fn iisoixfrm(&self) -> IISOIXFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IISOIXFRMR { bits } + } + #[doc = "Bit 21 - Incomplete periodic transfer mask(Host mode)/Incomplete isochronous OUT transfer mask(Device mode)"] + #[inline] + pub fn ipxfrm_iisooxfrm(&self) -> IPXFRM_IISOOXFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IPXFRM_IISOOXFRMR { bits } + } + #[doc = "Bit 24 - Host port interrupt mask"] + #[inline] + pub fn prtim(&self) -> PRTIMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PRTIMR { bits } + } + #[doc = "Bit 25 - Host channels interrupt mask"] + #[inline] + pub fn hcim(&self) -> HCIMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HCIMR { bits } + } + #[doc = "Bit 26 - Periodic TxFIFO empty mask"] + #[inline] + pub fn ptxfem(&self) -> PTXFEMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTXFEMR { bits } + } + #[doc = "Bit 28 - Connector ID status change mask"] + #[inline] + pub fn cidschgm(&self) -> CIDSCHGMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIDSCHGMR { bits } + } + #[doc = "Bit 29 - Disconnect detected interrupt mask"] + #[inline] + pub fn discint(&self) -> DISCINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DISCINTR { bits } + } + #[doc = "Bit 30 - Session request/new session detected interrupt mask"] + #[inline] + pub fn srqim(&self) -> SRQIMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRQIMR { bits } + } + #[doc = "Bit 31 - Resume/remote wakeup detected interrupt mask"] + #[inline] + pub fn wuim(&self) -> WUIMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUIMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Mode mismatch interrupt mask"] + #[inline] + pub fn mmism(&mut self) -> _MMISMW { + _MMISMW { w: self } + } + #[doc = "Bit 2 - OTG interrupt mask"] + #[inline] + pub fn otgint(&mut self) -> _OTGINTW { + _OTGINTW { w: self } + } + #[doc = "Bit 3 - Start of frame mask"] + #[inline] + pub fn sofm(&mut self) -> _SOFMW { + _SOFMW { w: self } + } + #[doc = "Bit 4 - Receive FIFO non-empty mask"] + #[inline] + pub fn rxflvlm(&mut self) -> _RXFLVLMW { + _RXFLVLMW { w: self } + } + #[doc = "Bit 5 - Non-periodic TxFIFO empty mask"] + #[inline] + pub fn nptxfem(&mut self) -> _NPTXFEMW { + _NPTXFEMW { w: self } + } + #[doc = "Bit 6 - Global non-periodic IN NAK effective mask"] + #[inline] + pub fn ginakeffm(&mut self) -> _GINAKEFFMW { + _GINAKEFFMW { w: self } + } + #[doc = "Bit 7 - Global OUT NAK effective mask"] + #[inline] + pub fn gonakeffm(&mut self) -> _GONAKEFFMW { + _GONAKEFFMW { w: self } + } + #[doc = "Bit 10 - Early suspend mask"] + #[inline] + pub fn esuspm(&mut self) -> _ESUSPMW { + _ESUSPMW { w: self } + } + #[doc = "Bit 11 - USB suspend mask"] + #[inline] + pub fn usbsuspm(&mut self) -> _USBSUSPMW { + _USBSUSPMW { w: self } + } + #[doc = "Bit 12 - USB reset mask"] + #[inline] + pub fn usbrst(&mut self) -> _USBRSTW { + _USBRSTW { w: self } + } + #[doc = "Bit 13 - Enumeration done mask"] + #[inline] + pub fn enumdnem(&mut self) -> _ENUMDNEMW { + _ENUMDNEMW { w: self } + } + #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt mask"] + #[inline] + pub fn isoodrpm(&mut self) -> _ISOODRPMW { + _ISOODRPMW { w: self } + } + #[doc = "Bit 15 - End of periodic frame interrupt mask"] + #[inline] + pub fn eopfm(&mut self) -> _EOPFMW { + _EOPFMW { w: self } + } + #[doc = "Bit 17 - Endpoint mismatch interrupt mask"] + #[inline] + pub fn epmism(&mut self) -> _EPMISMW { + _EPMISMW { w: self } + } + #[doc = "Bit 18 - IN endpoints interrupt mask"] + #[inline] + pub fn iepint(&mut self) -> _IEPINTW { + _IEPINTW { w: self } + } + #[doc = "Bit 19 - OUT endpoints interrupt mask"] + #[inline] + pub fn oepint(&mut self) -> _OEPINTW { + _OEPINTW { w: self } + } + #[doc = "Bit 20 - Incomplete isochronous IN transfer mask"] + #[inline] + pub fn iisoixfrm(&mut self) -> _IISOIXFRMW { + _IISOIXFRMW { w: self } + } + #[doc = "Bit 21 - Incomplete periodic transfer mask(Host mode)/Incomplete isochronous OUT transfer mask(Device mode)"] + #[inline] + pub fn ipxfrm_iisooxfrm(&mut self) -> _IPXFRM_IISOOXFRMW { + _IPXFRM_IISOOXFRMW { w: self } + } + #[doc = "Bit 25 - Host channels interrupt mask"] + #[inline] + pub fn hcim(&mut self) -> _HCIMW { + _HCIMW { w: self } + } + #[doc = "Bit 26 - Periodic TxFIFO empty mask"] + #[inline] + pub fn ptxfem(&mut self) -> _PTXFEMW { + _PTXFEMW { w: self } + } + #[doc = "Bit 28 - Connector ID status change mask"] + #[inline] + pub fn cidschgm(&mut self) -> _CIDSCHGMW { + _CIDSCHGMW { w: self } + } + #[doc = "Bit 29 - Disconnect detected interrupt mask"] + #[inline] + pub fn discint(&mut self) -> _DISCINTW { + _DISCINTW { w: self } + } + #[doc = "Bit 30 - Session request/new session detected interrupt mask"] + #[inline] + pub fn srqim(&mut self) -> _SRQIMW { + _SRQIMW { w: self } + } + #[doc = "Bit 31 - Resume/remote wakeup detected interrupt mask"] + #[inline] + pub fn wuim(&mut self) -> _WUIMW { + _WUIMW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gintsts/mod.rs b/src/otg_fs_global/fs_gintsts/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7003af4f51616cf869ef71b9a83014a5645af1a4 --- /dev/null +++ b/src/otg_fs_global/fs_gintsts/mod.rs @@ -0,0 +1,1231 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GINTSTS { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CMODR { + bits: bool, +} +impl CMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MMISR { + bits: bool, +} +impl MMISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OTGINTR { + bits: bool, +} +impl OTGINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SOFR { + bits: bool, +} +impl SOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFLVLR { + bits: bool, +} +impl RXFLVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NPTXFER { + bits: bool, +} +impl NPTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GINAKEFFR { + bits: bool, +} +impl GINAKEFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GOUTNAKEFFR { + bits: bool, +} +impl GOUTNAKEFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ESUSPR { + bits: bool, +} +impl ESUSPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBSUSPR { + bits: bool, +} +impl USBSUSPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USBRSTR { + bits: bool, +} +impl USBRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENUMDNER { + bits: bool, +} +impl ENUMDNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ISOODRPR { + bits: bool, +} +impl ISOODRPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EOPFR { + bits: bool, +} +impl EOPFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IEPINTR { + bits: bool, +} +impl IEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OEPINTR { + bits: bool, +} +impl OEPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IISOIXFRR { + bits: bool, +} +impl IISOIXFRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IPXFR_INCOMPISOOUTR { + bits: bool, +} +impl IPXFR_INCOMPISOOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HPRTINTR { + bits: bool, +} +impl HPRTINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HCINTR { + bits: bool, +} +impl HCINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PTXFER { + bits: bool, +} +impl PTXFER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIDSCHGR { + bits: bool, +} +impl CIDSCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DISCINTR { + bits: bool, +} +impl DISCINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRQINTR { + bits: bool, +} +impl SRQINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WKUPINTR { + bits: bool, +} +impl WKUPINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MMISW<'a> { + w: &'a mut W, +} +impl<'a> _MMISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SOFW<'a> { + w: &'a mut W, +} +impl<'a> _SOFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ESUSPW<'a> { + w: &'a mut W, +} +impl<'a> _ESUSPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBSUSPW<'a> { + w: &'a mut W, +} +impl<'a> _USBSUSPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USBRSTW<'a> { + w: &'a mut W, +} +impl<'a> _USBRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENUMDNEW<'a> { + w: &'a mut W, +} +impl<'a> _ENUMDNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ISOODRPW<'a> { + w: &'a mut W, +} +impl<'a> _ISOODRPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EOPFW<'a> { + w: &'a mut W, +} +impl<'a> _EOPFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IISOIXFRW<'a> { + w: &'a mut W, +} +impl<'a> _IISOIXFRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IPXFR_INCOMPISOOUTW<'a> { + w: &'a mut W, +} +impl<'a> _IPXFR_INCOMPISOOUTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CIDSCHGW<'a> { + w: &'a mut W, +} +impl<'a> _CIDSCHGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DISCINTW<'a> { + w: &'a mut W, +} +impl<'a> _DISCINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRQINTW<'a> { + w: &'a mut W, +} +impl<'a> _SRQINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WKUPINTW<'a> { + w: &'a mut W, +} +impl<'a> _WKUPINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Current mode of operation"] + #[inline] + pub fn cmod(&self) -> CMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMODR { bits } + } + #[doc = "Bit 1 - Mode mismatch interrupt"] + #[inline] + pub fn mmis(&self) -> MMISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MMISR { bits } + } + #[doc = "Bit 2 - OTG interrupt"] + #[inline] + pub fn otgint(&self) -> OTGINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTGINTR { bits } + } + #[doc = "Bit 3 - Start of frame"] + #[inline] + pub fn sof(&self) -> SOFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SOFR { bits } + } + #[doc = "Bit 4 - RxFIFO non-empty"] + #[inline] + pub fn rxflvl(&self) -> RXFLVLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFLVLR { bits } + } + #[doc = "Bit 5 - Non-periodic TxFIFO empty"] + #[inline] + pub fn nptxfe(&self) -> NPTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NPTXFER { bits } + } + #[doc = "Bit 6 - Global IN non-periodic NAK effective"] + #[inline] + pub fn ginakeff(&self) -> GINAKEFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GINAKEFFR { bits } + } + #[doc = "Bit 7 - Global OUT NAK effective"] + #[inline] + pub fn goutnakeff(&self) -> GOUTNAKEFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GOUTNAKEFFR { bits } + } + #[doc = "Bit 10 - Early suspend"] + #[inline] + pub fn esusp(&self) -> ESUSPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ESUSPR { bits } + } + #[doc = "Bit 11 - USB suspend"] + #[inline] + pub fn usbsusp(&self) -> USBSUSPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBSUSPR { bits } + } + #[doc = "Bit 12 - USB reset"] + #[inline] + pub fn usbrst(&self) -> USBRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USBRSTR { bits } + } + #[doc = "Bit 13 - Enumeration done"] + #[inline] + pub fn enumdne(&self) -> ENUMDNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENUMDNER { bits } + } + #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt"] + #[inline] + pub fn isoodrp(&self) -> ISOODRPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ISOODRPR { bits } + } + #[doc = "Bit 15 - End of periodic frame interrupt"] + #[inline] + pub fn eopf(&self) -> EOPFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EOPFR { bits } + } + #[doc = "Bit 18 - IN endpoint interrupt"] + #[inline] + pub fn iepint(&self) -> IEPINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IEPINTR { bits } + } + #[doc = "Bit 19 - OUT endpoint interrupt"] + #[inline] + pub fn oepint(&self) -> OEPINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OEPINTR { bits } + } + #[doc = "Bit 20 - Incomplete isochronous IN transfer"] + #[inline] + pub fn iisoixfr(&self) -> IISOIXFRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IISOIXFRR { bits } + } + #[doc = "Bit 21 - Incomplete periodic transfer(Host mode)/Incomplete isochronous OUT transfer(Device mode)"] + #[inline] + pub fn ipxfr_incompisoout(&self) -> IPXFR_INCOMPISOOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IPXFR_INCOMPISOOUTR { bits } + } + #[doc = "Bit 24 - Host port interrupt"] + #[inline] + pub fn hprtint(&self) -> HPRTINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HPRTINTR { bits } + } + #[doc = "Bit 25 - Host channels interrupt"] + #[inline] + pub fn hcint(&self) -> HCINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HCINTR { bits } + } + #[doc = "Bit 26 - Periodic TxFIFO empty"] + #[inline] + pub fn ptxfe(&self) -> PTXFER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PTXFER { bits } + } + #[doc = "Bit 28 - Connector ID status change"] + #[inline] + pub fn cidschg(&self) -> CIDSCHGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIDSCHGR { bits } + } + #[doc = "Bit 29 - Disconnect detected interrupt"] + #[inline] + pub fn discint(&self) -> DISCINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DISCINTR { bits } + } + #[doc = "Bit 30 - Session request/new session detected interrupt"] + #[inline] + pub fn srqint(&self) -> SRQINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRQINTR { bits } + } + #[doc = "Bit 31 - Resume/remote wakeup detected interrupt"] + #[inline] + pub fn wkupint(&self) -> WKUPINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WKUPINTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 67108896 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Mode mismatch interrupt"] + #[inline] + pub fn mmis(&mut self) -> _MMISW { + _MMISW { w: self } + } + #[doc = "Bit 3 - Start of frame"] + #[inline] + pub fn sof(&mut self) -> _SOFW { + _SOFW { w: self } + } + #[doc = "Bit 10 - Early suspend"] + #[inline] + pub fn esusp(&mut self) -> _ESUSPW { + _ESUSPW { w: self } + } + #[doc = "Bit 11 - USB suspend"] + #[inline] + pub fn usbsusp(&mut self) -> _USBSUSPW { + _USBSUSPW { w: self } + } + #[doc = "Bit 12 - USB reset"] + #[inline] + pub fn usbrst(&mut self) -> _USBRSTW { + _USBRSTW { w: self } + } + #[doc = "Bit 13 - Enumeration done"] + #[inline] + pub fn enumdne(&mut self) -> _ENUMDNEW { + _ENUMDNEW { w: self } + } + #[doc = "Bit 14 - Isochronous OUT packet dropped interrupt"] + #[inline] + pub fn isoodrp(&mut self) -> _ISOODRPW { + _ISOODRPW { w: self } + } + #[doc = "Bit 15 - End of periodic frame interrupt"] + #[inline] + pub fn eopf(&mut self) -> _EOPFW { + _EOPFW { w: self } + } + #[doc = "Bit 20 - Incomplete isochronous IN transfer"] + #[inline] + pub fn iisoixfr(&mut self) -> _IISOIXFRW { + _IISOIXFRW { w: self } + } + #[doc = "Bit 21 - Incomplete periodic transfer(Host mode)/Incomplete isochronous OUT transfer(Device mode)"] + #[inline] + pub fn ipxfr_incompisoout(&mut self) -> _IPXFR_INCOMPISOOUTW { + _IPXFR_INCOMPISOOUTW { w: self } + } + #[doc = "Bit 28 - Connector ID status change"] + #[inline] + pub fn cidschg(&mut self) -> _CIDSCHGW { + _CIDSCHGW { w: self } + } + #[doc = "Bit 29 - Disconnect detected interrupt"] + #[inline] + pub fn discint(&mut self) -> _DISCINTW { + _DISCINTW { w: self } + } + #[doc = "Bit 30 - Session request/new session detected interrupt"] + #[inline] + pub fn srqint(&mut self) -> _SRQINTW { + _SRQINTW { w: self } + } + #[doc = "Bit 31 - Resume/remote wakeup detected interrupt"] + #[inline] + pub fn wkupint(&mut self) -> _WKUPINTW { + _WKUPINTW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gnptxfsiz_device/mod.rs b/src/otg_fs_global/fs_gnptxfsiz_device/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b411975cd817b8d92bee73c32619bfbcc8cf8535 --- /dev/null +++ b/src/otg_fs_global/fs_gnptxfsiz_device/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GNPTXFSIZ_DEVICE { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TX0FSAR { + bits: u16, +} +impl TX0FSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TX0FDR { + bits: u16, +} +impl TX0FDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TX0FSAW<'a> { + w: &'a mut W, +} +impl<'a> _TX0FSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TX0FDW<'a> { + w: &'a mut W, +} +impl<'a> _TX0FDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Endpoint 0 transmit RAM start address"] + #[inline] + pub fn tx0fsa(&self) -> TX0FSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TX0FSAR { bits } + } + #[doc = "Bits 16:31 - Endpoint 0 TxFIFO depth"] + #[inline] + pub fn tx0fd(&self) -> TX0FDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TX0FDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 512 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Endpoint 0 transmit RAM start address"] + #[inline] + pub fn tx0fsa(&mut self) -> _TX0FSAW { + _TX0FSAW { w: self } + } + #[doc = "Bits 16:31 - Endpoint 0 TxFIFO depth"] + #[inline] + pub fn tx0fd(&mut self) -> _TX0FDW { + _TX0FDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gnptxfsiz_host/mod.rs b/src/otg_fs_global/fs_gnptxfsiz_host/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5c16c67219d9ba82581ae7453c9959837205254b --- /dev/null +++ b/src/otg_fs_global/fs_gnptxfsiz_host/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GNPTXFSIZ_HOST { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct NPTXFSAR { + bits: u16, +} +impl NPTXFSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NPTXFDR { + bits: u16, +} +impl NPTXFDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _NPTXFSAW<'a> { + w: &'a mut W, +} +impl<'a> _NPTXFSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NPTXFDW<'a> { + w: &'a mut W, +} +impl<'a> _NPTXFDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Non-periodic transmit RAM start address"] + #[inline] + pub fn nptxfsa(&self) -> NPTXFSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NPTXFSAR { bits } + } + #[doc = "Bits 16:31 - Non-periodic TxFIFO depth"] + #[inline] + pub fn nptxfd(&self) -> NPTXFDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NPTXFDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 512 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Non-periodic transmit RAM start address"] + #[inline] + pub fn nptxfsa(&mut self) -> _NPTXFSAW { + _NPTXFSAW { w: self } + } + #[doc = "Bits 16:31 - Non-periodic TxFIFO depth"] + #[inline] + pub fn nptxfd(&mut self) -> _NPTXFDW { + _NPTXFDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gnptxsts/mod.rs b/src/otg_fs_global/fs_gnptxsts/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f24fc4d8fd8964daf619296ea9d3d9d800892bd9 --- /dev/null +++ b/src/otg_fs_global/fs_gnptxsts/mod.rs @@ -0,0 +1,83 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_GNPTXSTS { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct NPTXFSAVR { + bits: u16, +} +impl NPTXFSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NPTQXSAVR { + bits: u8, +} +impl NPTQXSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NPTXQTOPR { + bits: u8, +} +impl NPTXQTOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Non-periodic TxFIFO space available"] + #[inline] + pub fn nptxfsav(&self) -> NPTXFSAVR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + NPTXFSAVR { bits } + } + #[doc = "Bits 16:23 - Non-periodic transmit request queue space available"] + #[inline] + pub fn nptqxsav(&self) -> NPTQXSAVR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + NPTQXSAVR { bits } + } + #[doc = "Bits 24:30 - Top of the non-periodic transmit request queue"] + #[inline] + pub fn nptxqtop(&self) -> NPTXQTOPR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + NPTXQTOPR { bits } + } +} diff --git a/src/otg_fs_global/fs_gotgctl/mod.rs b/src/otg_fs_global/fs_gotgctl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bf6a5bee0ce003b6b29e1310800880765cc64771 --- /dev/null +++ b/src/otg_fs_global/fs_gotgctl/mod.rs @@ -0,0 +1,486 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GOTGCTL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SRQSCSR { + bits: bool, +} +impl SRQSCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRQR { + bits: bool, +} +impl SRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HNGSCSR { + bits: bool, +} +impl HNGSCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HNPRQR { + bits: bool, +} +impl HNPRQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSHNPENR { + bits: bool, +} +impl HSHNPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DHNPENR { + bits: bool, +} +impl DHNPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CIDSTSR { + bits: bool, +} +impl CIDSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBCTR { + bits: bool, +} +impl DBCTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ASVLDR { + bits: bool, +} +impl ASVLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BSVLDR { + bits: bool, +} +impl BSVLDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SRQW<'a> { + w: &'a mut W, +} +impl<'a> _SRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HNPRQW<'a> { + w: &'a mut W, +} +impl<'a> _HNPRQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSHNPENW<'a> { + w: &'a mut W, +} +impl<'a> _HSHNPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DHNPENW<'a> { + w: &'a mut W, +} +impl<'a> _DHNPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Session request success"] + #[inline] + pub fn srqscs(&self) -> SRQSCSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRQSCSR { bits } + } + #[doc = "Bit 1 - Session request"] + #[inline] + pub fn srq(&self) -> SRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRQR { bits } + } + #[doc = "Bit 8 - Host negotiation success"] + #[inline] + pub fn hngscs(&self) -> HNGSCSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HNGSCSR { bits } + } + #[doc = "Bit 9 - HNP request"] + #[inline] + pub fn hnprq(&self) -> HNPRQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HNPRQR { bits } + } + #[doc = "Bit 10 - Host set HNP enable"] + #[inline] + pub fn hshnpen(&self) -> HSHNPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSHNPENR { bits } + } + #[doc = "Bit 11 - Device HNP enabled"] + #[inline] + pub fn dhnpen(&self) -> DHNPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DHNPENR { bits } + } + #[doc = "Bit 16 - Connector ID status"] + #[inline] + pub fn cidsts(&self) -> CIDSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CIDSTSR { bits } + } + #[doc = "Bit 17 - Long/short debounce time"] + #[inline] + pub fn dbct(&self) -> DBCTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBCTR { bits } + } + #[doc = "Bit 18 - A-session valid"] + #[inline] + pub fn asvld(&self) -> ASVLDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ASVLDR { bits } + } + #[doc = "Bit 19 - B-session valid"] + #[inline] + pub fn bsvld(&self) -> BSVLDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BSVLDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2048 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Session request"] + #[inline] + pub fn srq(&mut self) -> _SRQW { + _SRQW { w: self } + } + #[doc = "Bit 9 - HNP request"] + #[inline] + pub fn hnprq(&mut self) -> _HNPRQW { + _HNPRQW { w: self } + } + #[doc = "Bit 10 - Host set HNP enable"] + #[inline] + pub fn hshnpen(&mut self) -> _HSHNPENW { + _HSHNPENW { w: self } + } + #[doc = "Bit 11 - Device HNP enabled"] + #[inline] + pub fn dhnpen(&mut self) -> _DHNPENW { + _DHNPENW { w: self } + } +} diff --git a/src/otg_fs_global/fs_gotgint/mod.rs b/src/otg_fs_global/fs_gotgint/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a4cc6e140a5da2f5f29834fb62de945f22d742fa --- /dev/null +++ b/src/otg_fs_global/fs_gotgint/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GOTGINT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SEDETR { + bits: bool, +} +impl SEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRSSCHGR { + bits: bool, +} +impl SRSSCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HNSSCHGR { + bits: bool, +} +impl HNSSCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HNGDETR { + bits: bool, +} +impl HNGDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADTOCHGR { + bits: bool, +} +impl ADTOCHGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBCDNER { + bits: bool, +} +impl DBCDNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SEDETW<'a> { + w: &'a mut W, +} +impl<'a> _SEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRSSCHGW<'a> { + w: &'a mut W, +} +impl<'a> _SRSSCHGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HNSSCHGW<'a> { + w: &'a mut W, +} +impl<'a> _HNSSCHGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HNGDETW<'a> { + w: &'a mut W, +} +impl<'a> _HNGDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADTOCHGW<'a> { + w: &'a mut W, +} +impl<'a> _ADTOCHGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBCDNEW<'a> { + w: &'a mut W, +} +impl<'a> _DBCDNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 2 - Session end detected"] + #[inline] + pub fn sedet(&self) -> SEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SEDETR { bits } + } + #[doc = "Bit 8 - Session request success status change"] + #[inline] + pub fn srsschg(&self) -> SRSSCHGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRSSCHGR { bits } + } + #[doc = "Bit 9 - Host negotiation success status change"] + #[inline] + pub fn hnsschg(&self) -> HNSSCHGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HNSSCHGR { bits } + } + #[doc = "Bit 17 - Host negotiation detected"] + #[inline] + pub fn hngdet(&self) -> HNGDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HNGDETR { bits } + } + #[doc = "Bit 18 - A-device timeout change"] + #[inline] + pub fn adtochg(&self) -> ADTOCHGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADTOCHGR { bits } + } + #[doc = "Bit 19 - Debounce done"] + #[inline] + pub fn dbcdne(&self) -> DBCDNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBCDNER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 2 - Session end detected"] + #[inline] + pub fn sedet(&mut self) -> _SEDETW { + _SEDETW { w: self } + } + #[doc = "Bit 8 - Session request success status change"] + #[inline] + pub fn srsschg(&mut self) -> _SRSSCHGW { + _SRSSCHGW { w: self } + } + #[doc = "Bit 9 - Host negotiation success status change"] + #[inline] + pub fn hnsschg(&mut self) -> _HNSSCHGW { + _HNSSCHGW { w: self } + } + #[doc = "Bit 17 - Host negotiation detected"] + #[inline] + pub fn hngdet(&mut self) -> _HNGDETW { + _HNGDETW { w: self } + } + #[doc = "Bit 18 - A-device timeout change"] + #[inline] + pub fn adtochg(&mut self) -> _ADTOCHGW { + _ADTOCHGW { w: self } + } + #[doc = "Bit 19 - Debounce done"] + #[inline] + pub fn dbcdne(&mut self) -> _DBCDNEW { + _DBCDNEW { w: self } + } +} diff --git a/src/otg_fs_global/fs_grstctl/mod.rs b/src/otg_fs_global/fs_grstctl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cce69565c16f9aee28054a3306aa8becd0782671 --- /dev/null +++ b/src/otg_fs_global/fs_grstctl/mod.rs @@ -0,0 +1,431 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GRSTCTL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CSRSTR { + bits: bool, +} +impl CSRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSRSTR { + bits: bool, +} +impl HSRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FCRSTR { + bits: bool, +} +impl FCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFFLSHR { + bits: bool, +} +impl RXFFLSHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFFLSHR { + bits: bool, +} +impl TXFFLSHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFNUMR { + bits: u8, +} +impl TXFNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct AHBIDLR { + bits: bool, +} +impl AHBIDLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CSRSTW<'a> { + w: &'a mut W, +} +impl<'a> _CSRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSRSTW<'a> { + w: &'a mut W, +} +impl<'a> _HSRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _FCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXFFLSHW<'a> { + w: &'a mut W, +} +impl<'a> _RXFFLSHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFFLSHW<'a> { + w: &'a mut W, +} +impl<'a> _TXFFLSHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFNUMW<'a> { + w: &'a mut W, +} +impl<'a> _TXFNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Core soft reset"] + #[inline] + pub fn csrst(&self) -> CSRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CSRSTR { bits } + } + #[doc = "Bit 1 - HCLK soft reset"] + #[inline] + pub fn hsrst(&self) -> HSRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSRSTR { bits } + } + #[doc = "Bit 2 - Host frame counter reset"] + #[inline] + pub fn fcrst(&self) -> FCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FCRSTR { bits } + } + #[doc = "Bit 4 - RxFIFO flush"] + #[inline] + pub fn rxfflsh(&self) -> RXFFLSHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFFLSHR { bits } + } + #[doc = "Bit 5 - TxFIFO flush"] + #[inline] + pub fn txfflsh(&self) -> TXFFLSHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFFLSHR { bits } + } + #[doc = "Bits 6:10 - TxFIFO number"] + #[inline] + pub fn txfnum(&self) -> TXFNUMR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TXFNUMR { bits } + } + #[doc = "Bit 31 - AHB master idle"] + #[inline] + pub fn ahbidl(&self) -> AHBIDLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AHBIDLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 536870912 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Core soft reset"] + #[inline] + pub fn csrst(&mut self) -> _CSRSTW { + _CSRSTW { w: self } + } + #[doc = "Bit 1 - HCLK soft reset"] + #[inline] + pub fn hsrst(&mut self) -> _HSRSTW { + _HSRSTW { w: self } + } + #[doc = "Bit 2 - Host frame counter reset"] + #[inline] + pub fn fcrst(&mut self) -> _FCRSTW { + _FCRSTW { w: self } + } + #[doc = "Bit 4 - RxFIFO flush"] + #[inline] + pub fn rxfflsh(&mut self) -> _RXFFLSHW { + _RXFFLSHW { w: self } + } + #[doc = "Bit 5 - TxFIFO flush"] + #[inline] + pub fn txfflsh(&mut self) -> _TXFFLSHW { + _TXFFLSHW { w: self } + } + #[doc = "Bits 6:10 - TxFIFO number"] + #[inline] + pub fn txfnum(&mut self) -> _TXFNUMW { + _TXFNUMW { w: self } + } +} diff --git a/src/otg_fs_global/fs_grxfsiz/mod.rs b/src/otg_fs_global/fs_grxfsiz/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7fe264b9537bac92a1f532fd518116accf79dc3 --- /dev/null +++ b/src/otg_fs_global/fs_grxfsiz/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GRXFSIZ { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RXFDR { + bits: u16, +} +impl RXFDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RXFDW<'a> { + w: &'a mut W, +} +impl<'a> _RXFDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - RxFIFO depth"] + #[inline] + pub fn rxfd(&self) -> RXFDR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + RXFDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 512 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - RxFIFO depth"] + #[inline] + pub fn rxfd(&mut self) -> _RXFDW { + _RXFDW { w: self } + } +} diff --git a/src/otg_fs_global/fs_grxstsr_device/mod.rs b/src/otg_fs_global/fs_grxstsr_device/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d4bcf298384a8bd2f507fce920310b0a018368a5 --- /dev/null +++ b/src/otg_fs_global/fs_grxstsr_device/mod.rs @@ -0,0 +1,125 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_GRXSTSR_DEVICE { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BCNTR { + bits: u16, +} +impl BCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTSTSR { + bits: u8, +} +impl PKTSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FRMNUMR { + bits: u8, +} +impl FRMNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:3 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bits 4:14 - Byte count"] + #[inline] + pub fn bcnt(&self) -> BCNTR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + BCNTR { bits } + } + #[doc = "Bits 15:16 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } + #[doc = "Bits 17:20 - Packet status"] + #[inline] + pub fn pktsts(&self) -> PKTSTSR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PKTSTSR { bits } + } + #[doc = "Bits 21:24 - Frame number"] + #[inline] + pub fn frmnum(&self) -> FRMNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FRMNUMR { bits } + } +} diff --git a/src/otg_fs_global/fs_grxstsr_host/mod.rs b/src/otg_fs_global/fs_grxstsr_host/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6142c697d2ed2f671e27909d879211fbbd06b09 --- /dev/null +++ b/src/otg_fs_global/fs_grxstsr_host/mod.rs @@ -0,0 +1,125 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_GRXSTSR_HOST { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BCNTR { + bits: u16, +} +impl BCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTSTSR { + bits: u8, +} +impl PKTSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FRMNUMR { + bits: u8, +} +impl FRMNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:3 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bits 4:14 - Byte count"] + #[inline] + pub fn bcnt(&self) -> BCNTR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + BCNTR { bits } + } + #[doc = "Bits 15:16 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } + #[doc = "Bits 17:20 - Packet status"] + #[inline] + pub fn pktsts(&self) -> PKTSTSR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PKTSTSR { bits } + } + #[doc = "Bits 21:24 - Frame number"] + #[inline] + pub fn frmnum(&self) -> FRMNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FRMNUMR { bits } + } +} diff --git a/src/otg_fs_global/fs_gusbcfg/mod.rs b/src/otg_fs_global/fs_gusbcfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1a7c9254bdb41b741f271d6f0fde78450df3cd98 --- /dev/null +++ b/src/otg_fs_global/fs_gusbcfg/mod.rs @@ -0,0 +1,469 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_GUSBCFG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TOCALR { + bits: u8, +} +impl TOCALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SRPCAPR { + bits: bool, +} +impl SRPCAPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HNPCAPR { + bits: bool, +} +impl HNPCAPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRDTR { + bits: u8, +} +impl TRDTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FHMODR { + bits: bool, +} +impl FHMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FDMODR { + bits: bool, +} +impl FDMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTXPKTR { + bits: bool, +} +impl CTXPKTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TOCALW<'a> { + w: &'a mut W, +} +impl<'a> _TOCALW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PHYSELW<'a> { + w: &'a mut W, +} +impl<'a> _PHYSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRPCAPW<'a> { + w: &'a mut W, +} +impl<'a> _SRPCAPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HNPCAPW<'a> { + w: &'a mut W, +} +impl<'a> _HNPCAPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRDTW<'a> { + w: &'a mut W, +} +impl<'a> _TRDTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FHMODW<'a> { + w: &'a mut W, +} +impl<'a> _FHMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FDMODW<'a> { + w: &'a mut W, +} +impl<'a> _FDMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTXPKTW<'a> { + w: &'a mut W, +} +impl<'a> _CTXPKTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:2 - FS timeout calibration"] + #[inline] + pub fn tocal(&self) -> TOCALR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TOCALR { bits } + } + #[doc = "Bit 8 - SRP-capable"] + #[inline] + pub fn srpcap(&self) -> SRPCAPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRPCAPR { bits } + } + #[doc = "Bit 9 - HNP-capable"] + #[inline] + pub fn hnpcap(&self) -> HNPCAPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HNPCAPR { bits } + } + #[doc = "Bits 10:13 - USB turnaround time"] + #[inline] + pub fn trdt(&self) -> TRDTR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TRDTR { bits } + } + #[doc = "Bit 29 - Force host mode"] + #[inline] + pub fn fhmod(&self) -> FHMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FHMODR { bits } + } + #[doc = "Bit 30 - Force device mode"] + #[inline] + pub fn fdmod(&self) -> FDMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FDMODR { bits } + } + #[doc = "Bit 31 - Corrupt Tx packet"] + #[inline] + pub fn ctxpkt(&self) -> CTXPKTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTXPKTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2560 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:2 - FS timeout calibration"] + #[inline] + pub fn tocal(&mut self) -> _TOCALW { + _TOCALW { w: self } + } + #[doc = "Bit 6 - Full Speed serial transceiver select"] + #[inline] + pub fn physel(&mut self) -> _PHYSELW { + _PHYSELW { w: self } + } + #[doc = "Bit 8 - SRP-capable"] + #[inline] + pub fn srpcap(&mut self) -> _SRPCAPW { + _SRPCAPW { w: self } + } + #[doc = "Bit 9 - HNP-capable"] + #[inline] + pub fn hnpcap(&mut self) -> _HNPCAPW { + _HNPCAPW { w: self } + } + #[doc = "Bits 10:13 - USB turnaround time"] + #[inline] + pub fn trdt(&mut self) -> _TRDTW { + _TRDTW { w: self } + } + #[doc = "Bit 29 - Force host mode"] + #[inline] + pub fn fhmod(&mut self) -> _FHMODW { + _FHMODW { w: self } + } + #[doc = "Bit 30 - Force device mode"] + #[inline] + pub fn fdmod(&mut self) -> _FDMODW { + _FDMODW { w: self } + } + #[doc = "Bit 31 - Corrupt Tx packet"] + #[inline] + pub fn ctxpkt(&mut self) -> _CTXPKTW { + _CTXPKTW { w: self } + } +} diff --git a/src/otg_fs_global/fs_hptxfsiz/mod.rs b/src/otg_fs_global/fs_hptxfsiz/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..bf57b44091450d5a8249ed6e181c3ac9765c4653 --- /dev/null +++ b/src/otg_fs_global/fs_hptxfsiz/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HPTXFSIZ { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PTXSAR { + bits: u16, +} +impl PTXSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTXFSIZR { + bits: u16, +} +impl PTXFSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PTXSAW<'a> { + w: &'a mut W, +} +impl<'a> _PTXSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTXFSIZW<'a> { + w: &'a mut W, +} +impl<'a> _PTXFSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Host periodic TxFIFO start address"] + #[inline] + pub fn ptxsa(&self) -> PTXSAR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PTXSAR { bits } + } + #[doc = "Bits 16:31 - Host periodic TxFIFO depth"] + #[inline] + pub fn ptxfsiz(&self) -> PTXFSIZR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PTXFSIZR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 33555968 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Host periodic TxFIFO start address"] + #[inline] + pub fn ptxsa(&mut self) -> _PTXSAW { + _PTXSAW { w: self } + } + #[doc = "Bits 16:31 - Host periodic TxFIFO depth"] + #[inline] + pub fn ptxfsiz(&mut self) -> _PTXFSIZW { + _PTXFSIZW { w: self } + } +} diff --git a/src/otg_fs_global/mod.rs b/src/otg_fs_global/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..607bb25fb4ec81fb078fc4f87de6bf08335d53a6 --- /dev/null +++ b/src/otg_fs_global/mod.rs @@ -0,0 +1,155 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - OTG_FS control and status register (OTG_FS_GOTGCTL)"] + pub fs_gotgctl: FS_GOTGCTL, + #[doc = "0x04 - OTG_FS interrupt register (OTG_FS_GOTGINT)"] + pub fs_gotgint: FS_GOTGINT, + #[doc = "0x08 - OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"] + pub fs_gahbcfg: FS_GAHBCFG, + #[doc = "0x0c - OTG_FS USB configuration register (OTG_FS_GUSBCFG)"] + pub fs_gusbcfg: FS_GUSBCFG, + #[doc = "0x10 - OTG_FS reset register (OTG_FS_GRSTCTL)"] + pub fs_grstctl: FS_GRSTCTL, + #[doc = "0x14 - OTG_FS core interrupt register (OTG_FS_GINTSTS)"] + pub fs_gintsts: FS_GINTSTS, + #[doc = "0x18 - OTG_FS interrupt mask register (OTG_FS_GINTMSK)"] + pub fs_gintmsk: FS_GINTMSK, + #[doc = "0x1c - OTG_FS Receive status debug read(Device mode)"] + pub fs_grxstsr_device: FS_GRXSTSR_DEVICE, + _reserved0: [u8; 4usize], + #[doc = "0x24 - OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"] + pub fs_grxfsiz: FS_GRXFSIZ, + #[doc = "0x28 - OTG_FS non-periodic transmit FIFO size register (Device mode)"] + pub fs_gnptxfsiz_device: FS_GNPTXFSIZ_DEVICE, + #[doc = "0x2c - OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"] + pub fs_gnptxsts: FS_GNPTXSTS, + _reserved1: [u8; 8usize], + #[doc = "0x38 - OTG_FS general core configuration register (OTG_FS_GCCFG)"] + pub fs_gccfg: FS_GCCFG, + #[doc = "0x3c - core ID register"] + pub fs_cid: FS_CID, + _reserved2: [u8; 192usize], + #[doc = "0x100 - OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"] + pub fs_hptxfsiz: FS_HPTXFSIZ, + #[doc = "0x104 - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"] + pub fs_dieptxf1: FS_DIEPTXF1, + #[doc = "0x108 - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"] + pub fs_dieptxf2: FS_DIEPTXF2, + #[doc = "0x10c - OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"] + pub fs_dieptxf3: FS_DIEPTXF3, +} +#[doc = "OTG_FS control and status register (OTG_FS_GOTGCTL)"] +pub struct FS_GOTGCTL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS control and status register (OTG_FS_GOTGCTL)"] +pub mod fs_gotgctl; +#[doc = "OTG_FS interrupt register (OTG_FS_GOTGINT)"] +pub struct FS_GOTGINT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS interrupt register (OTG_FS_GOTGINT)"] +pub mod fs_gotgint; +#[doc = "OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"] +pub struct FS_GAHBCFG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS AHB configuration register (OTG_FS_GAHBCFG)"] +pub mod fs_gahbcfg; +#[doc = "OTG_FS USB configuration register (OTG_FS_GUSBCFG)"] +pub struct FS_GUSBCFG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS USB configuration register (OTG_FS_GUSBCFG)"] +pub mod fs_gusbcfg; +#[doc = "OTG_FS reset register (OTG_FS_GRSTCTL)"] +pub struct FS_GRSTCTL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS reset register (OTG_FS_GRSTCTL)"] +pub mod fs_grstctl; +#[doc = "OTG_FS core interrupt register (OTG_FS_GINTSTS)"] +pub struct FS_GINTSTS { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS core interrupt register (OTG_FS_GINTSTS)"] +pub mod fs_gintsts; +#[doc = "OTG_FS interrupt mask register (OTG_FS_GINTMSK)"] +pub struct FS_GINTMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS interrupt mask register (OTG_FS_GINTMSK)"] +pub mod fs_gintmsk; +#[doc = "OTG_FS Receive status debug read(Device mode)"] +pub struct FS_GRXSTSR_DEVICE { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Receive status debug read(Device mode)"] +pub mod fs_grxstsr_device; +#[doc = "OTG_FS Receive status debug read(Host mode)"] +pub struct FS_GRXSTSR_HOST { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Receive status debug read(Host mode)"] +pub mod fs_grxstsr_host; +#[doc = "OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"] +pub struct FS_GRXFSIZ { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)"] +pub mod fs_grxfsiz; +#[doc = "OTG_FS non-periodic transmit FIFO size register (Device mode)"] +pub struct FS_GNPTXFSIZ_DEVICE { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS non-periodic transmit FIFO size register (Device mode)"] +pub mod fs_gnptxfsiz_device; +#[doc = "OTG_FS non-periodic transmit FIFO size register (Host mode)"] +pub struct FS_GNPTXFSIZ_HOST { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS non-periodic transmit FIFO size register (Host mode)"] +pub mod fs_gnptxfsiz_host; +#[doc = "OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"] +pub struct FS_GNPTXSTS { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)"] +pub mod fs_gnptxsts; +#[doc = "OTG_FS general core configuration register (OTG_FS_GCCFG)"] +pub struct FS_GCCFG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS general core configuration register (OTG_FS_GCCFG)"] +pub mod fs_gccfg; +#[doc = "core ID register"] +pub struct FS_CID { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "core ID register"] +pub mod fs_cid; +#[doc = "OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"] +pub struct FS_HPTXFSIZ { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)"] +pub mod fs_hptxfsiz; +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"] +pub struct FS_DIEPTXF1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)"] +pub mod fs_dieptxf1; +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"] +pub struct FS_DIEPTXF2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)"] +pub mod fs_dieptxf2; +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"] +pub struct FS_DIEPTXF3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)"] +pub mod fs_dieptxf3; diff --git a/src/otg_fs_host/fs_hcchar0/mod.rs b/src/otg_fs_host/fs_hcchar0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a3f4547adaa44c90d97fbb8222d859bef40526c3 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar0/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar1/mod.rs b/src/otg_fs_host/fs_hcchar1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f59287c3fa7147afbb975544de5b3926736e4cf5 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar1/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar2/mod.rs b/src/otg_fs_host/fs_hcchar2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a163e6cad94ea7f5bf9ebd683756df056621df97 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar2/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar3/mod.rs b/src/otg_fs_host/fs_hcchar3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e1009ad3f7337eb82713f3de5da148eefc5b596d --- /dev/null +++ b/src/otg_fs_host/fs_hcchar3/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar4/mod.rs b/src/otg_fs_host/fs_hcchar4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3942245a27b55f39660b3f2b2a9c94eeb8e6dcce --- /dev/null +++ b/src/otg_fs_host/fs_hcchar4/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar5/mod.rs b/src/otg_fs_host/fs_hcchar5/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1d6b3ec1694206e6653fecdb8e48edf952dd1ec1 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar5/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR5 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar6/mod.rs b/src/otg_fs_host/fs_hcchar6/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5eddfe099cb5d2b8a98908c37819d89a125a63d0 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar6/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR6 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcchar7/mod.rs b/src/otg_fs_host/fs_hcchar7/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..448231380bd678f95a239891089535bcc9216654 --- /dev/null +++ b/src/otg_fs_host/fs_hcchar7/mod.rs @@ -0,0 +1,564 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCCHAR7 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MPSIZR { + bits: u16, +} +impl MPSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPNUMR { + bits: u8, +} +impl EPNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EPDIRR { + bits: bool, +} +impl EPDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSDEVR { + bits: bool, +} +impl LSDEVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EPTYPR { + bits: u8, +} +impl EPTYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCNTR { + bits: u8, +} +impl MCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DADR { + bits: u8, +} +impl DADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ODDFRMR { + bits: bool, +} +impl ODDFRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHDISR { + bits: bool, +} +impl CHDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHENAR { + bits: bool, +} +impl CHENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MPSIZW<'a> { + w: &'a mut W, +} +impl<'a> _MPSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPNUMW<'a> { + w: &'a mut W, +} +impl<'a> _EPNUMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPDIRW<'a> { + w: &'a mut W, +} +impl<'a> _EPDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSDEVW<'a> { + w: &'a mut W, +} +impl<'a> _LSDEVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EPTYPW<'a> { + w: &'a mut W, +} +impl<'a> _EPTYPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCNTW<'a> { + w: &'a mut W, +} +impl<'a> _MCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DADW<'a> { + w: &'a mut W, +} +impl<'a> _DADW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ODDFRMW<'a> { + w: &'a mut W, +} +impl<'a> _ODDFRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHDISW<'a> { + w: &'a mut W, +} +impl<'a> _CHDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHENAW<'a> { + w: &'a mut W, +} +impl<'a> _CHENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&self) -> MPSIZR { + let bits = { + const MASK: u16 = 2047; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MPSIZR { bits } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&self) -> EPNUMR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPNUMR { bits } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&self) -> EPDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EPDIRR { bits } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&self) -> LSDEVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSDEVR { bits } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&self) -> EPTYPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EPTYPR { bits } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&self) -> MCNTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCNTR { bits } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&self) -> DADR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DADR { bits } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&self) -> ODDFRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ODDFRMR { bits } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&self) -> CHDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHDISR { bits } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&self) -> CHENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHENAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:10 - Maximum packet size"] + #[inline] + pub fn mpsiz(&mut self) -> _MPSIZW { + _MPSIZW { w: self } + } + #[doc = "Bits 11:14 - Endpoint number"] + #[inline] + pub fn epnum(&mut self) -> _EPNUMW { + _EPNUMW { w: self } + } + #[doc = "Bit 15 - Endpoint direction"] + #[inline] + pub fn epdir(&mut self) -> _EPDIRW { + _EPDIRW { w: self } + } + #[doc = "Bit 17 - Low-speed device"] + #[inline] + pub fn lsdev(&mut self) -> _LSDEVW { + _LSDEVW { w: self } + } + #[doc = "Bits 18:19 - Endpoint type"] + #[inline] + pub fn eptyp(&mut self) -> _EPTYPW { + _EPTYPW { w: self } + } + #[doc = "Bits 20:21 - Multicount"] + #[inline] + pub fn mcnt(&mut self) -> _MCNTW { + _MCNTW { w: self } + } + #[doc = "Bits 22:28 - Device address"] + #[inline] + pub fn dad(&mut self) -> _DADW { + _DADW { w: self } + } + #[doc = "Bit 29 - Odd frame"] + #[inline] + pub fn oddfrm(&mut self) -> _ODDFRMW { + _ODDFRMW { w: self } + } + #[doc = "Bit 30 - Channel disable"] + #[inline] + pub fn chdis(&mut self) -> _CHDISW { + _CHDISW { w: self } + } + #[doc = "Bit 31 - Channel enable"] + #[inline] + pub fn chena(&mut self) -> _CHENAW { + _CHENAW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcfg/mod.rs b/src/otg_fs_host/fs_hcfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..81da5b5825675aaaef2eb22450c8fafbf5db13bc --- /dev/null +++ b/src/otg_fs_host/fs_hcfg/mod.rs @@ -0,0 +1,136 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCFG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSLSPCSR { + bits: u8, +} +impl FSLSPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FSLSSR { + bits: bool, +} +impl FSLSSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSLSPCSW<'a> { + w: &'a mut W, +} +impl<'a> _FSLSPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - FS/LS PHY clock select"] + #[inline] + pub fn fslspcs(&self) -> FSLSPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSLSPCSR { bits } + } + #[doc = "Bit 2 - FS- and LS-only support"] + #[inline] + pub fn fslss(&self) -> FSLSSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSLSSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - FS/LS PHY clock select"] + #[inline] + pub fn fslspcs(&mut self) -> _FSLSPCSW { + _FSLSPCSW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint0/mod.rs b/src/otg_fs_host/fs_hcint0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..995b4d3065df41061533af5dce9f767fa04abd21 --- /dev/null +++ b/src/otg_fs_host/fs_hcint0/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint1/mod.rs b/src/otg_fs_host/fs_hcint1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..74ea425dc7d1a13660bb0938cd7d26fa168a703c --- /dev/null +++ b/src/otg_fs_host/fs_hcint1/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint2/mod.rs b/src/otg_fs_host/fs_hcint2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1b83f6382f70ec4358a37f3e2f06f7266462c71a --- /dev/null +++ b/src/otg_fs_host/fs_hcint2/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint3/mod.rs b/src/otg_fs_host/fs_hcint3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..834ca5660730a1a8ed8ebfb72232001b3bbdfb80 --- /dev/null +++ b/src/otg_fs_host/fs_hcint3/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint4/mod.rs b/src/otg_fs_host/fs_hcint4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ee0211c3bc27dc2f8148dba51a8a5c27f1a6ecde --- /dev/null +++ b/src/otg_fs_host/fs_hcint4/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint5/mod.rs b/src/otg_fs_host/fs_hcint5/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9020f4d39a844d1fad2db8e1cdb1a4787c0cba82 --- /dev/null +++ b/src/otg_fs_host/fs_hcint5/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT5 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint6/mod.rs b/src/otg_fs_host/fs_hcint6/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c76b47254d61805a9b6f3df555834cff2f625553 --- /dev/null +++ b/src/otg_fs_host/fs_hcint6/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT6 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcint7/mod.rs b/src/otg_fs_host/fs_hcint7/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8f933a1466bb33aa5de1025f53dcf3034ca8ffb1 --- /dev/null +++ b/src/otg_fs_host/fs_hcint7/mod.rs @@ -0,0 +1,595 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINT7 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCR { + bits: bool, +} +impl XFRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHR { + bits: bool, +} +impl CHHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLR { + bits: bool, +} +impl STALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKR { + bits: bool, +} +impl NAKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKR { + bits: bool, +} +impl ACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRR { + bits: bool, +} +impl TXERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRR { + bits: bool, +} +impl BBERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORR { + bits: bool, +} +impl FRMORR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRR { + bits: bool, +} +impl DTERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHW<'a> { + w: &'a mut W, +} +impl<'a> _CHHW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLW<'a> { + w: &'a mut W, +} +impl<'a> _STALLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKW<'a> { + w: &'a mut W, +} +impl<'a> _NAKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKW<'a> { + w: &'a mut W, +} +impl<'a> _ACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&self) -> XFRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCR { bits } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&self) -> CHHR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&self) -> STALLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&self) -> NAKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&self) -> ACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKR { bits } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&self) -> TXERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRR { bits } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&self) -> BBERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRR { bits } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&self) -> FRMORR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORR { bits } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&self) -> DTERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed"] + #[inline] + pub fn xfrc(&mut self) -> _XFRCW { + _XFRCW { w: self } + } + #[doc = "Bit 1 - Channel halted"] + #[inline] + pub fn chh(&mut self) -> _CHHW { + _CHHW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt"] + #[inline] + pub fn stall(&mut self) -> _STALLW { + _STALLW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt"] + #[inline] + pub fn nak(&mut self) -> _NAKW { + _NAKW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt"] + #[inline] + pub fn ack(&mut self) -> _ACKW { + _ACKW { w: self } + } + #[doc = "Bit 7 - Transaction error"] + #[inline] + pub fn txerr(&mut self) -> _TXERRW { + _TXERRW { w: self } + } + #[doc = "Bit 8 - Babble error"] + #[inline] + pub fn bberr(&mut self) -> _BBERRW { + _BBERRW { w: self } + } + #[doc = "Bit 9 - Frame overrun"] + #[inline] + pub fn frmor(&mut self) -> _FRMORW { + _FRMORW { w: self } + } + #[doc = "Bit 10 - Data toggle error"] + #[inline] + pub fn dterr(&mut self) -> _DTERRW { + _DTERRW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk0/mod.rs b/src/otg_fs_host/fs_hcintmsk0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..58fc72ac445d92bbbb4fb15cab682c01e1f9135d --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk0/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk1/mod.rs b/src/otg_fs_host/fs_hcintmsk1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b444efb112aafdfeaf3e99dbaed868347f5d8f9f --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk1/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk2/mod.rs b/src/otg_fs_host/fs_hcintmsk2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..95dcdecc65e1f2ecce28f5dfc0dbfd2ebca31cad --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk2/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk3/mod.rs b/src/otg_fs_host/fs_hcintmsk3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b9091351f0aba59fd804c690ad7eed21931f3e74 --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk3/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk4/mod.rs b/src/otg_fs_host/fs_hcintmsk4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..731e0dd23e9ea91c7676e64d6c6189c4d78fc9f1 --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk4/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk5/mod.rs b/src/otg_fs_host/fs_hcintmsk5/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..16eefec8f08701674ba36e2074d881e42e9340dc --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk5/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK5 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk6/mod.rs b/src/otg_fs_host/fs_hcintmsk6/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..23d36aef47a82b36a2afa2416e710906b7121bc4 --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk6/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK6 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hcintmsk7/mod.rs b/src/otg_fs_host/fs_hcintmsk7/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b116f13772705925ebb3ffd6a33ec4cfeb18d871 --- /dev/null +++ b/src/otg_fs_host/fs_hcintmsk7/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCINTMSK7 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRCMR { + bits: bool, +} +impl XFRCMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CHHMR { + bits: bool, +} +impl CHHMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STALLMR { + bits: bool, +} +impl STALLMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NAKMR { + bits: bool, +} +impl NAKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ACKMR { + bits: bool, +} +impl ACKMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NYETR { + bits: bool, +} +impl NYETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXERRMR { + bits: bool, +} +impl TXERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BBERRMR { + bits: bool, +} +impl BBERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FRMORMR { + bits: bool, +} +impl FRMORMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTERRMR { + bits: bool, +} +impl DTERRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _XFRCMW<'a> { + w: &'a mut W, +} +impl<'a> _XFRCMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CHHMW<'a> { + w: &'a mut W, +} +impl<'a> _CHHMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STALLMW<'a> { + w: &'a mut W, +} +impl<'a> _STALLMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NAKMW<'a> { + w: &'a mut W, +} +impl<'a> _NAKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ACKMW<'a> { + w: &'a mut W, +} +impl<'a> _ACKMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NYETW<'a> { + w: &'a mut W, +} +impl<'a> _NYETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXERRMW<'a> { + w: &'a mut W, +} +impl<'a> _TXERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BBERRMW<'a> { + w: &'a mut W, +} +impl<'a> _BBERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRMORMW<'a> { + w: &'a mut W, +} +impl<'a> _FRMORMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTERRMW<'a> { + w: &'a mut W, +} +impl<'a> _DTERRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&self) -> XFRCMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + XFRCMR { bits } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&self) -> CHHMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CHHMR { bits } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&self) -> STALLMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STALLMR { bits } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&self) -> NAKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NAKMR { bits } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&self) -> ACKMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ACKMR { bits } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&self) -> NYETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NYETR { bits } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&self) -> TXERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXERRMR { bits } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&self) -> BBERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BBERRMR { bits } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&self) -> FRMORMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FRMORMR { bits } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&self) -> DTERRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTERRMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Transfer completed mask"] + #[inline] + pub fn xfrcm(&mut self) -> _XFRCMW { + _XFRCMW { w: self } + } + #[doc = "Bit 1 - Channel halted mask"] + #[inline] + pub fn chhm(&mut self) -> _CHHMW { + _CHHMW { w: self } + } + #[doc = "Bit 3 - STALL response received interrupt mask"] + #[inline] + pub fn stallm(&mut self) -> _STALLMW { + _STALLMW { w: self } + } + #[doc = "Bit 4 - NAK response received interrupt mask"] + #[inline] + pub fn nakm(&mut self) -> _NAKMW { + _NAKMW { w: self } + } + #[doc = "Bit 5 - ACK response received/transmitted interrupt mask"] + #[inline] + pub fn ackm(&mut self) -> _ACKMW { + _ACKMW { w: self } + } + #[doc = "Bit 6 - response received interrupt mask"] + #[inline] + pub fn nyet(&mut self) -> _NYETW { + _NYETW { w: self } + } + #[doc = "Bit 7 - Transaction error mask"] + #[inline] + pub fn txerrm(&mut self) -> _TXERRMW { + _TXERRMW { w: self } + } + #[doc = "Bit 8 - Babble error mask"] + #[inline] + pub fn bberrm(&mut self) -> _BBERRMW { + _BBERRMW { w: self } + } + #[doc = "Bit 9 - Frame overrun mask"] + #[inline] + pub fn frmorm(&mut self) -> _FRMORMW { + _FRMORMW { w: self } + } + #[doc = "Bit 10 - Data toggle error mask"] + #[inline] + pub fn dterrm(&mut self) -> _DTERRMW { + _DTERRMW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz0/mod.rs b/src/otg_fs_host/fs_hctsiz0/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1cf605470bb68e2fcacb5f37c28006a041b5696a --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz0/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ0 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz1/mod.rs b/src/otg_fs_host/fs_hctsiz1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c28b96a5af433cbe9bff8fb1f7f5a006efe912ac --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz1/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz2/mod.rs b/src/otg_fs_host/fs_hctsiz2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..611bbbf86723011d2ea7ec4c25d40f871fa61462 --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz2/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz3/mod.rs b/src/otg_fs_host/fs_hctsiz3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0ed508a3190e5cee26a3bc16035804530c365f86 --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz3/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz4/mod.rs b/src/otg_fs_host/fs_hctsiz4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f3794e3acb13cb0268b0ae3d7ac75f1794594f80 --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz4/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz5/mod.rs b/src/otg_fs_host/fs_hctsiz5/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d5c41c8372708424618ba770def9395ee13583b8 --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz5/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ5 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz6/mod.rs b/src/otg_fs_host/fs_hctsiz6/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19da0b04f86916f8530c64fedf7308884ed8bd2a --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz6/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ6 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hctsiz7/mod.rs b/src/otg_fs_host/fs_hctsiz7/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..03b5509884cf016834b4eae37429deeb8561eefe --- /dev/null +++ b/src/otg_fs_host/fs_hctsiz7/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HCTSIZ7 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct XFRSIZR { + bits: u32, +} +impl XFRSIZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PKTCNTR { + bits: u16, +} +impl PKTCNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DPIDR { + bits: u8, +} +impl DPIDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _XFRSIZW<'a> { + w: &'a mut W, +} +impl<'a> _XFRSIZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PKTCNTW<'a> { + w: &'a mut W, +} +impl<'a> _PKTCNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DPIDW<'a> { + w: &'a mut W, +} +impl<'a> _DPIDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&self) -> XFRSIZR { + let bits = { + const MASK: u32 = 524287; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + XFRSIZR { bits } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&self) -> PKTCNTR { + let bits = { + const MASK: u16 = 1023; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PKTCNTR { bits } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&self) -> DPIDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DPIDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:18 - Transfer size"] + #[inline] + pub fn xfrsiz(&mut self) -> _XFRSIZW { + _XFRSIZW { w: self } + } + #[doc = "Bits 19:28 - Packet count"] + #[inline] + pub fn pktcnt(&mut self) -> _PKTCNTW { + _PKTCNTW { w: self } + } + #[doc = "Bits 29:30 - Data PID"] + #[inline] + pub fn dpid(&mut self) -> _DPIDW { + _DPIDW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hfnum/mod.rs b/src/otg_fs_host/fs_hfnum/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9fc08bde57544ed9d6349789f76e75163a9c970a --- /dev/null +++ b/src/otg_fs_host/fs_hfnum/mod.rs @@ -0,0 +1,62 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FS_HFNUM { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct FRNUMR { + bits: u16, +} +impl FRNUMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FTREMR { + bits: u16, +} +impl FTREMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Frame number"] + #[inline] + pub fn frnum(&self) -> FRNUMR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FRNUMR { bits } + } + #[doc = "Bits 16:31 - Frame time remaining"] + #[inline] + pub fn ftrem(&self) -> FTREMR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FTREMR { bits } + } +} diff --git a/src/otg_fs_host/fs_hprt/mod.rs b/src/otg_fs_host/fs_hprt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..16eb78dc98d6e45ae99b3f89b296ac142b406799 --- /dev/null +++ b/src/otg_fs_host/fs_hprt/mod.rs @@ -0,0 +1,681 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HPRT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PCSTSR { + bits: bool, +} +impl PCSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PCDETR { + bits: bool, +} +impl PCDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PENAR { + bits: bool, +} +impl PENAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PENCHNGR { + bits: bool, +} +impl PENCHNGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct POCAR { + bits: bool, +} +impl POCAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct POCCHNGR { + bits: bool, +} +impl POCCHNGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PRESR { + bits: bool, +} +impl PRESR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PSUSPR { + bits: bool, +} +impl PSUSPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PRSTR { + bits: bool, +} +impl PRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLSTSR { + bits: u8, +} +impl PLSTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PPWRR { + bits: bool, +} +impl PPWRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PTCTLR { + bits: u8, +} +impl PTCTLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSPDR { + bits: u8, +} +impl PSPDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PCDETW<'a> { + w: &'a mut W, +} +impl<'a> _PCDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PENAW<'a> { + w: &'a mut W, +} +impl<'a> _PENAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PENCHNGW<'a> { + w: &'a mut W, +} +impl<'a> _PENCHNGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _POCCHNGW<'a> { + w: &'a mut W, +} +impl<'a> _POCCHNGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRESW<'a> { + w: &'a mut W, +} +impl<'a> _PRESW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSUSPW<'a> { + w: &'a mut W, +} +impl<'a> _PSUSPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRSTW<'a> { + w: &'a mut W, +} +impl<'a> _PRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PPWRW<'a> { + w: &'a mut W, +} +impl<'a> _PPWRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PTCTLW<'a> { + w: &'a mut W, +} +impl<'a> _PTCTLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Port connect status"] + #[inline] + pub fn pcsts(&self) -> PCSTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PCSTSR { bits } + } + #[doc = "Bit 1 - Port connect detected"] + #[inline] + pub fn pcdet(&self) -> PCDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PCDETR { bits } + } + #[doc = "Bit 2 - Port enable"] + #[inline] + pub fn pena(&self) -> PENAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PENAR { bits } + } + #[doc = "Bit 3 - Port enable/disable change"] + #[inline] + pub fn penchng(&self) -> PENCHNGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PENCHNGR { bits } + } + #[doc = "Bit 4 - Port overcurrent active"] + #[inline] + pub fn poca(&self) -> POCAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + POCAR { bits } + } + #[doc = "Bit 5 - Port overcurrent change"] + #[inline] + pub fn pocchng(&self) -> POCCHNGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + POCCHNGR { bits } + } + #[doc = "Bit 6 - Port resume"] + #[inline] + pub fn pres(&self) -> PRESR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PRESR { bits } + } + #[doc = "Bit 7 - Port suspend"] + #[inline] + pub fn psusp(&self) -> PSUSPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PSUSPR { bits } + } + #[doc = "Bit 8 - Port reset"] + #[inline] + pub fn prst(&self) -> PRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PRSTR { bits } + } + #[doc = "Bits 10:11 - Port line status"] + #[inline] + pub fn plsts(&self) -> PLSTSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLSTSR { bits } + } + #[doc = "Bit 12 - Port power"] + #[inline] + pub fn ppwr(&self) -> PPWRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PPWRR { bits } + } + #[doc = "Bits 13:16 - Port test control"] + #[inline] + pub fn ptctl(&self) -> PTCTLR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PTCTLR { bits } + } + #[doc = "Bits 17:18 - Port speed"] + #[inline] + pub fn pspd(&self) -> PSPDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSPDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Port connect detected"] + #[inline] + pub fn pcdet(&mut self) -> _PCDETW { + _PCDETW { w: self } + } + #[doc = "Bit 2 - Port enable"] + #[inline] + pub fn pena(&mut self) -> _PENAW { + _PENAW { w: self } + } + #[doc = "Bit 3 - Port enable/disable change"] + #[inline] + pub fn penchng(&mut self) -> _PENCHNGW { + _PENCHNGW { w: self } + } + #[doc = "Bit 5 - Port overcurrent change"] + #[inline] + pub fn pocchng(&mut self) -> _POCCHNGW { + _POCCHNGW { w: self } + } + #[doc = "Bit 6 - Port resume"] + #[inline] + pub fn pres(&mut self) -> _PRESW { + _PRESW { w: self } + } + #[doc = "Bit 7 - Port suspend"] + #[inline] + pub fn psusp(&mut self) -> _PSUSPW { + _PSUSPW { w: self } + } + #[doc = "Bit 8 - Port reset"] + #[inline] + pub fn prst(&mut self) -> _PRSTW { + _PRSTW { w: self } + } + #[doc = "Bit 12 - Port power"] + #[inline] + pub fn ppwr(&mut self) -> _PPWRW { + _PPWRW { w: self } + } + #[doc = "Bits 13:16 - Port test control"] + #[inline] + pub fn ptctl(&mut self) -> _PTCTLW { + _PTCTLW { w: self } + } +} diff --git a/src/otg_fs_host/fs_hptxsts/mod.rs b/src/otg_fs_host/fs_hptxsts/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..199a58ea78a528e98d226c0b48f8792d29582884 --- /dev/null +++ b/src/otg_fs_host/fs_hptxsts/mod.rs @@ -0,0 +1,147 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_HPTXSTS { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PTXFSAVLR { + bits: u16, +} +impl PTXFSAVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTXQSAVR { + bits: u8, +} +impl PTXQSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PTXQTOPR { + bits: u8, +} +impl PTXQTOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PTXFSAVLW<'a> { + w: &'a mut W, +} +impl<'a> _PTXFSAVLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Periodic transmit data FIFO space available"] + #[inline] + pub fn ptxfsavl(&self) -> PTXFSAVLR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PTXFSAVLR { bits } + } + #[doc = "Bits 16:23 - Periodic transmit request queue space available"] + #[inline] + pub fn ptxqsav(&self) -> PTXQSAVR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PTXQSAVR { bits } + } + #[doc = "Bits 24:31 - Top of the periodic transmit request queue"] + #[inline] + pub fn ptxqtop(&self) -> PTXQTOPR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PTXQTOPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 524544 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Periodic transmit data FIFO space available"] + #[inline] + pub fn ptxfsavl(&mut self) -> _PTXFSAVLW { + _PTXFSAVLW { w: self } + } +} diff --git a/src/otg_fs_host/haint/mod.rs b/src/otg_fs_host/haint/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1ef38acb0df072da327a76d8e001c64cd0285600 --- /dev/null +++ b/src/otg_fs_host/haint/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::HAINT { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct HAINTR { + bits: u16, +} +impl HAINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Channel interrupts"] + #[inline] + pub fn haint(&self) -> HAINTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + HAINTR { bits } + } +} diff --git a/src/otg_fs_host/haintmsk/mod.rs b/src/otg_fs_host/haintmsk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4f0b3bcd017009d48e81649c4541148380737f04 --- /dev/null +++ b/src/otg_fs_host/haintmsk/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::HAINTMSK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct HAINTMR { + bits: u16, +} +impl HAINTMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _HAINTMW<'a> { + w: &'a mut W, +} +impl<'a> _HAINTMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Channel interrupt mask"] + #[inline] + pub fn haintm(&self) -> HAINTMR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + HAINTMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Channel interrupt mask"] + #[inline] + pub fn haintm(&mut self) -> _HAINTMW { + _HAINTMW { w: self } + } +} diff --git a/src/otg_fs_host/hfir/mod.rs b/src/otg_fs_host/hfir/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7d88157c28e6b5d9451cb90a1d80e92b8ff68f5c --- /dev/null +++ b/src/otg_fs_host/hfir/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::HFIR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FRIVLR { + bits: u16, +} +impl FRIVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FRIVLW<'a> { + w: &'a mut W, +} +impl<'a> _FRIVLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Frame interval"] + #[inline] + pub fn frivl(&self) -> FRIVLR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + FRIVLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 60000 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Frame interval"] + #[inline] + pub fn frivl(&mut self) -> _FRIVLW { + _FRIVLW { w: self } + } +} diff --git a/src/otg_fs_host/mod.rs b/src/otg_fs_host/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dd357c083de6013fd42e9f385e3a2284b5c5febf --- /dev/null +++ b/src/otg_fs_host/mod.rs @@ -0,0 +1,334 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - OTG_FS host configuration register (OTG_FS_HCFG)"] + pub fs_hcfg: FS_HCFG, + #[doc = "0x04 - OTG_FS Host frame interval register"] + pub hfir: HFIR, + #[doc = "0x08 - OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"] + pub fs_hfnum: FS_HFNUM, + _reserved0: [u8; 4usize], + #[doc = "0x10 - OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"] + pub fs_hptxsts: FS_HPTXSTS, + #[doc = "0x14 - OTG_FS Host all channels interrupt register"] + pub haint: HAINT, + #[doc = "0x18 - OTG_FS host all channels interrupt mask register"] + pub haintmsk: HAINTMSK, + _reserved1: [u8; 36usize], + #[doc = "0x40 - OTG_FS host port control and status register (OTG_FS_HPRT)"] + pub fs_hprt: FS_HPRT, + _reserved2: [u8; 188usize], + #[doc = "0x100 - OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"] + pub fs_hcchar0: FS_HCCHAR0, + _reserved3: [u8; 4usize], + #[doc = "0x108 - OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"] + pub fs_hcint0: FS_HCINT0, + #[doc = "0x10c - OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"] + pub fs_hcintmsk0: FS_HCINTMSK0, + #[doc = "0x110 - OTG_FS host channel-0 transfer size register"] + pub fs_hctsiz0: FS_HCTSIZ0, + _reserved4: [u8; 12usize], + #[doc = "0x120 - OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"] + pub fs_hcchar1: FS_HCCHAR1, + _reserved5: [u8; 4usize], + #[doc = "0x128 - OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"] + pub fs_hcint1: FS_HCINT1, + #[doc = "0x12c - OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"] + pub fs_hcintmsk1: FS_HCINTMSK1, + #[doc = "0x130 - OTG_FS host channel-1 transfer size register"] + pub fs_hctsiz1: FS_HCTSIZ1, + _reserved6: [u8; 12usize], + #[doc = "0x140 - OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"] + pub fs_hcchar2: FS_HCCHAR2, + _reserved7: [u8; 4usize], + #[doc = "0x148 - OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"] + pub fs_hcint2: FS_HCINT2, + #[doc = "0x14c - OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"] + pub fs_hcintmsk2: FS_HCINTMSK2, + #[doc = "0x150 - OTG_FS host channel-2 transfer size register"] + pub fs_hctsiz2: FS_HCTSIZ2, + _reserved8: [u8; 12usize], + #[doc = "0x160 - OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"] + pub fs_hcchar3: FS_HCCHAR3, + _reserved9: [u8; 4usize], + #[doc = "0x168 - OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"] + pub fs_hcint3: FS_HCINT3, + #[doc = "0x16c - OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"] + pub fs_hcintmsk3: FS_HCINTMSK3, + #[doc = "0x170 - OTG_FS host channel-3 transfer size register"] + pub fs_hctsiz3: FS_HCTSIZ3, + _reserved10: [u8; 12usize], + #[doc = "0x180 - OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"] + pub fs_hcchar4: FS_HCCHAR4, + _reserved11: [u8; 4usize], + #[doc = "0x188 - OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"] + pub fs_hcint4: FS_HCINT4, + #[doc = "0x18c - OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"] + pub fs_hcintmsk4: FS_HCINTMSK4, + #[doc = "0x190 - OTG_FS host channel-x transfer size register"] + pub fs_hctsiz4: FS_HCTSIZ4, + _reserved12: [u8; 12usize], + #[doc = "0x1a0 - OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"] + pub fs_hcchar5: FS_HCCHAR5, + _reserved13: [u8; 4usize], + #[doc = "0x1a8 - OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"] + pub fs_hcint5: FS_HCINT5, + #[doc = "0x1ac - OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"] + pub fs_hcintmsk5: FS_HCINTMSK5, + #[doc = "0x1b0 - OTG_FS host channel-5 transfer size register"] + pub fs_hctsiz5: FS_HCTSIZ5, + _reserved14: [u8; 12usize], + #[doc = "0x1c0 - OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"] + pub fs_hcchar6: FS_HCCHAR6, + _reserved15: [u8; 4usize], + #[doc = "0x1c8 - OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"] + pub fs_hcint6: FS_HCINT6, + #[doc = "0x1cc - OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"] + pub fs_hcintmsk6: FS_HCINTMSK6, + #[doc = "0x1d0 - OTG_FS host channel-6 transfer size register"] + pub fs_hctsiz6: FS_HCTSIZ6, + _reserved16: [u8; 12usize], + #[doc = "0x1e0 - OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"] + pub fs_hcchar7: FS_HCCHAR7, + _reserved17: [u8; 4usize], + #[doc = "0x1e8 - OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"] + pub fs_hcint7: FS_HCINT7, + #[doc = "0x1ec - OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"] + pub fs_hcintmsk7: FS_HCINTMSK7, + #[doc = "0x1f0 - OTG_FS host channel-7 transfer size register"] + pub fs_hctsiz7: FS_HCTSIZ7, +} +#[doc = "OTG_FS host configuration register (OTG_FS_HCFG)"] +pub struct FS_HCFG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host configuration register (OTG_FS_HCFG)"] +pub mod fs_hcfg; +#[doc = "OTG_FS Host frame interval register"] +pub struct HFIR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Host frame interval register"] +pub mod hfir; +#[doc = "OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"] +pub struct FS_HFNUM { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host frame number/frame time remaining register (OTG_FS_HFNUM)"] +pub mod fs_hfnum; +#[doc = "OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"] +pub struct FS_HPTXSTS { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS_Host periodic transmit FIFO/queue status register (OTG_FS_HPTXSTS)"] +pub mod fs_hptxsts; +#[doc = "OTG_FS Host all channels interrupt register"] +pub struct HAINT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS Host all channels interrupt register"] +pub mod haint; +#[doc = "OTG_FS host all channels interrupt mask register"] +pub struct HAINTMSK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host all channels interrupt mask register"] +pub mod haintmsk; +#[doc = "OTG_FS host port control and status register (OTG_FS_HPRT)"] +pub struct FS_HPRT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host port control and status register (OTG_FS_HPRT)"] +pub mod fs_hprt; +#[doc = "OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"] +pub struct FS_HCCHAR0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-0 characteristics register (OTG_FS_HCCHAR0)"] +pub mod fs_hcchar0; +#[doc = "OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"] +pub struct FS_HCCHAR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-1 characteristics register (OTG_FS_HCCHAR1)"] +pub mod fs_hcchar1; +#[doc = "OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"] +pub struct FS_HCCHAR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-2 characteristics register (OTG_FS_HCCHAR2)"] +pub mod fs_hcchar2; +#[doc = "OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"] +pub struct FS_HCCHAR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-3 characteristics register (OTG_FS_HCCHAR3)"] +pub mod fs_hcchar3; +#[doc = "OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"] +pub struct FS_HCCHAR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-4 characteristics register (OTG_FS_HCCHAR4)"] +pub mod fs_hcchar4; +#[doc = "OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"] +pub struct FS_HCCHAR5 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-5 characteristics register (OTG_FS_HCCHAR5)"] +pub mod fs_hcchar5; +#[doc = "OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"] +pub struct FS_HCCHAR6 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-6 characteristics register (OTG_FS_HCCHAR6)"] +pub mod fs_hcchar6; +#[doc = "OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"] +pub struct FS_HCCHAR7 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-7 characteristics register (OTG_FS_HCCHAR7)"] +pub mod fs_hcchar7; +#[doc = "OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"] +pub struct FS_HCINT0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-0 interrupt register (OTG_FS_HCINT0)"] +pub mod fs_hcint0; +#[doc = "OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"] +pub struct FS_HCINT1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-1 interrupt register (OTG_FS_HCINT1)"] +pub mod fs_hcint1; +#[doc = "OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"] +pub struct FS_HCINT2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-2 interrupt register (OTG_FS_HCINT2)"] +pub mod fs_hcint2; +#[doc = "OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"] +pub struct FS_HCINT3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-3 interrupt register (OTG_FS_HCINT3)"] +pub mod fs_hcint3; +#[doc = "OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"] +pub struct FS_HCINT4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-4 interrupt register (OTG_FS_HCINT4)"] +pub mod fs_hcint4; +#[doc = "OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"] +pub struct FS_HCINT5 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-5 interrupt register (OTG_FS_HCINT5)"] +pub mod fs_hcint5; +#[doc = "OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"] +pub struct FS_HCINT6 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-6 interrupt register (OTG_FS_HCINT6)"] +pub mod fs_hcint6; +#[doc = "OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"] +pub struct FS_HCINT7 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-7 interrupt register (OTG_FS_HCINT7)"] +pub mod fs_hcint7; +#[doc = "OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"] +pub struct FS_HCINTMSK0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-0 mask register (OTG_FS_HCINTMSK0)"] +pub mod fs_hcintmsk0; +#[doc = "OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"] +pub struct FS_HCINTMSK1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-1 mask register (OTG_FS_HCINTMSK1)"] +pub mod fs_hcintmsk1; +#[doc = "OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"] +pub struct FS_HCINTMSK2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-2 mask register (OTG_FS_HCINTMSK2)"] +pub mod fs_hcintmsk2; +#[doc = "OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"] +pub struct FS_HCINTMSK3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-3 mask register (OTG_FS_HCINTMSK3)"] +pub mod fs_hcintmsk3; +#[doc = "OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"] +pub struct FS_HCINTMSK4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-4 mask register (OTG_FS_HCINTMSK4)"] +pub mod fs_hcintmsk4; +#[doc = "OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"] +pub struct FS_HCINTMSK5 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-5 mask register (OTG_FS_HCINTMSK5)"] +pub mod fs_hcintmsk5; +#[doc = "OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"] +pub struct FS_HCINTMSK6 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-6 mask register (OTG_FS_HCINTMSK6)"] +pub mod fs_hcintmsk6; +#[doc = "OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"] +pub struct FS_HCINTMSK7 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-7 mask register (OTG_FS_HCINTMSK7)"] +pub mod fs_hcintmsk7; +#[doc = "OTG_FS host channel-0 transfer size register"] +pub struct FS_HCTSIZ0 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-0 transfer size register"] +pub mod fs_hctsiz0; +#[doc = "OTG_FS host channel-1 transfer size register"] +pub struct FS_HCTSIZ1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-1 transfer size register"] +pub mod fs_hctsiz1; +#[doc = "OTG_FS host channel-2 transfer size register"] +pub struct FS_HCTSIZ2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-2 transfer size register"] +pub mod fs_hctsiz2; +#[doc = "OTG_FS host channel-3 transfer size register"] +pub struct FS_HCTSIZ3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-3 transfer size register"] +pub mod fs_hctsiz3; +#[doc = "OTG_FS host channel-x transfer size register"] +pub struct FS_HCTSIZ4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-x transfer size register"] +pub mod fs_hctsiz4; +#[doc = "OTG_FS host channel-5 transfer size register"] +pub struct FS_HCTSIZ5 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-5 transfer size register"] +pub mod fs_hctsiz5; +#[doc = "OTG_FS host channel-6 transfer size register"] +pub struct FS_HCTSIZ6 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-6 transfer size register"] +pub mod fs_hctsiz6; +#[doc = "OTG_FS host channel-7 transfer size register"] +pub struct FS_HCTSIZ7 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS host channel-7 transfer size register"] +pub mod fs_hctsiz7; diff --git a/src/otg_fs_pwrclk/fs_pcgcctl/mod.rs b/src/otg_fs_pwrclk/fs_pcgcctl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..627db7fe238cecdbea34ccd7f19436a46b7d51cc --- /dev/null +++ b/src/otg_fs_pwrclk/fs_pcgcctl/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FS_PCGCCTL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct STPPCLKR { + bits: bool, +} +impl STPPCLKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GATEHCLKR { + bits: bool, +} +impl GATEHCLKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PHYSUSPR { + bits: bool, +} +impl PHYSUSPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _STPPCLKW<'a> { + w: &'a mut W, +} +impl<'a> _STPPCLKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GATEHCLKW<'a> { + w: &'a mut W, +} +impl<'a> _GATEHCLKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PHYSUSPW<'a> { + w: &'a mut W, +} +impl<'a> _PHYSUSPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Stop PHY clock"] + #[inline] + pub fn stppclk(&self) -> STPPCLKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STPPCLKR { bits } + } + #[doc = "Bit 1 - Gate HCLK"] + #[inline] + pub fn gatehclk(&self) -> GATEHCLKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GATEHCLKR { bits } + } + #[doc = "Bit 4 - PHY Suspended"] + #[inline] + pub fn physusp(&self) -> PHYSUSPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PHYSUSPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Stop PHY clock"] + #[inline] + pub fn stppclk(&mut self) -> _STPPCLKW { + _STPPCLKW { w: self } + } + #[doc = "Bit 1 - Gate HCLK"] + #[inline] + pub fn gatehclk(&mut self) -> _GATEHCLKW { + _GATEHCLKW { w: self } + } + #[doc = "Bit 4 - PHY Suspended"] + #[inline] + pub fn physusp(&mut self) -> _PHYSUSPW { + _PHYSUSPW { w: self } + } +} diff --git a/src/otg_fs_pwrclk/mod.rs b/src/otg_fs_pwrclk/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..98ded6906d3905475b538fb7229702c6fb6941e3 --- /dev/null +++ b/src/otg_fs_pwrclk/mod.rs @@ -0,0 +1,12 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"] + pub fs_pcgcctl: FS_PCGCCTL, +} +#[doc = "OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"] +pub struct FS_PCGCCTL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "OTG_FS power and clock gating control register (OTG_FS_PCGCCTL)"] +pub mod fs_pcgcctl; diff --git a/src/pwr/cr/mod.rs b/src/pwr/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e625d33d281c73a80c0e2d6234ecca8467724654 --- /dev/null +++ b/src/pwr/cr/mod.rs @@ -0,0 +1,618 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct VOSR { + bits: u8, +} +impl VOSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADCDC1R { + bits: bool, +} +impl ADCDC1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FPDSR { + bits: bool, +} +impl FPDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBPR { + bits: bool, +} +impl DBPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLSR { + bits: u8, +} +impl PLSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PVDER { + bits: bool, +} +impl PVDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CSBFR { + bits: bool, +} +impl CSBFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CWUFR { + bits: bool, +} +impl CWUFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PDDSR { + bits: bool, +} +impl PDDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LPDSR { + bits: bool, +} +impl LPDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _VOSW<'a> { + w: &'a mut W, +} +impl<'a> _VOSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADCDC1W<'a> { + w: &'a mut W, +} +impl<'a> _ADCDC1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FPDSW<'a> { + w: &'a mut W, +} +impl<'a> _FPDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBPW<'a> { + w: &'a mut W, +} +impl<'a> _DBPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLSW<'a> { + w: &'a mut W, +} +impl<'a> _PLSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PVDEW<'a> { + w: &'a mut W, +} +impl<'a> _PVDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CSBFW<'a> { + w: &'a mut W, +} +impl<'a> _CSBFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CWUFW<'a> { + w: &'a mut W, +} +impl<'a> _CWUFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PDDSW<'a> { + w: &'a mut W, +} +impl<'a> _PDDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LPDSW<'a> { + w: &'a mut W, +} +impl<'a> _LPDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - Regulator voltage scaling output selection"] + #[inline] + pub fn vos(&self) -> VOSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + VOSR { bits } + } + #[doc = "Bit 13 - ADCDC1"] + #[inline] + pub fn adcdc1(&self) -> ADCDC1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADCDC1R { bits } + } + #[doc = "Bit 9 - Flash power down in Stop mode"] + #[inline] + pub fn fpds(&self) -> FPDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FPDSR { bits } + } + #[doc = "Bit 8 - Disable backup domain write protection"] + #[inline] + pub fn dbp(&self) -> DBPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBPR { bits } + } + #[doc = "Bits 5:7 - PVD level selection"] + #[inline] + pub fn pls(&self) -> PLSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLSR { bits } + } + #[doc = "Bit 4 - Power voltage detector enable"] + #[inline] + pub fn pvde(&self) -> PVDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PVDER { bits } + } + #[doc = "Bit 3 - Clear standby flag"] + #[inline] + pub fn csbf(&self) -> CSBFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CSBFR { bits } + } + #[doc = "Bit 2 - Clear wakeup flag"] + #[inline] + pub fn cwuf(&self) -> CWUFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CWUFR { bits } + } + #[doc = "Bit 1 - Power down deepsleep"] + #[inline] + pub fn pdds(&self) -> PDDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PDDSR { bits } + } + #[doc = "Bit 0 - Low-power deep sleep"] + #[inline] + pub fn lpds(&self) -> LPDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LPDSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - Regulator voltage scaling output selection"] + #[inline] + pub fn vos(&mut self) -> _VOSW { + _VOSW { w: self } + } + #[doc = "Bit 13 - ADCDC1"] + #[inline] + pub fn adcdc1(&mut self) -> _ADCDC1W { + _ADCDC1W { w: self } + } + #[doc = "Bit 9 - Flash power down in Stop mode"] + #[inline] + pub fn fpds(&mut self) -> _FPDSW { + _FPDSW { w: self } + } + #[doc = "Bit 8 - Disable backup domain write protection"] + #[inline] + pub fn dbp(&mut self) -> _DBPW { + _DBPW { w: self } + } + #[doc = "Bits 5:7 - PVD level selection"] + #[inline] + pub fn pls(&mut self) -> _PLSW { + _PLSW { w: self } + } + #[doc = "Bit 4 - Power voltage detector enable"] + #[inline] + pub fn pvde(&mut self) -> _PVDEW { + _PVDEW { w: self } + } + #[doc = "Bit 3 - Clear standby flag"] + #[inline] + pub fn csbf(&mut self) -> _CSBFW { + _CSBFW { w: self } + } + #[doc = "Bit 2 - Clear wakeup flag"] + #[inline] + pub fn cwuf(&mut self) -> _CWUFW { + _CWUFW { w: self } + } + #[doc = "Bit 1 - Power down deepsleep"] + #[inline] + pub fn pdds(&mut self) -> _PDDSW { + _PDDSW { w: self } + } + #[doc = "Bit 0 - Low-power deep sleep"] + #[inline] + pub fn lpds(&mut self) -> _LPDSW { + _LPDSW { w: self } + } +} diff --git a/src/pwr/csr/mod.rs b/src/pwr/csr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..55cc46c979dfb7ef83d8ba60a7975123a80fc33b --- /dev/null +++ b/src/pwr/csr/mod.rs @@ -0,0 +1,365 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WUFR { + bits: bool, +} +impl WUFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SBFR { + bits: bool, +} +impl SBFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PVDOR { + bits: bool, +} +impl PVDOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BRRR { + bits: bool, +} +impl BRRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EWUPR { + bits: bool, +} +impl EWUPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BRER { + bits: bool, +} +impl BRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct VOSRDYR { + bits: bool, +} +impl VOSRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _EWUPW<'a> { + w: &'a mut W, +} +impl<'a> _EWUPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BREW<'a> { + w: &'a mut W, +} +impl<'a> _BREW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _VOSRDYW<'a> { + w: &'a mut W, +} +impl<'a> _VOSRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Wakeup flag"] + #[inline] + pub fn wuf(&self) -> WUFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUFR { bits } + } + #[doc = "Bit 1 - Standby flag"] + #[inline] + pub fn sbf(&self) -> SBFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SBFR { bits } + } + #[doc = "Bit 2 - PVD output"] + #[inline] + pub fn pvdo(&self) -> PVDOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PVDOR { bits } + } + #[doc = "Bit 3 - Backup regulator ready"] + #[inline] + pub fn brr(&self) -> BRRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BRRR { bits } + } + #[doc = "Bit 8 - Enable WKUP pin"] + #[inline] + pub fn ewup(&self) -> EWUPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EWUPR { bits } + } + #[doc = "Bit 9 - Backup regulator enable"] + #[inline] + pub fn bre(&self) -> BRER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BRER { bits } + } + #[doc = "Bit 14 - Regulator voltage scaling output selection ready bit"] + #[inline] + pub fn vosrdy(&self) -> VOSRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + VOSRDYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 8 - Enable WKUP pin"] + #[inline] + pub fn ewup(&mut self) -> _EWUPW { + _EWUPW { w: self } + } + #[doc = "Bit 9 - Backup regulator enable"] + #[inline] + pub fn bre(&mut self) -> _BREW { + _BREW { w: self } + } + #[doc = "Bit 14 - Regulator voltage scaling output selection ready bit"] + #[inline] + pub fn vosrdy(&mut self) -> _VOSRDYW { + _VOSRDYW { w: self } + } +} diff --git a/src/pwr/mod.rs b/src/pwr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c5d42b20412b2dc777df74697b33b5e3ce97d9c1 --- /dev/null +++ b/src/pwr/mod.rs @@ -0,0 +1,20 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - power control register"] + pub cr: CR, + #[doc = "0x04 - power control/status register"] + pub csr: CSR, +} +#[doc = "power control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "power control register"] +pub mod cr; +#[doc = "power control/status register"] +pub struct CSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "power control/status register"] +pub mod csr; diff --git a/src/quadspi/abr/mod.rs b/src/quadspi/abr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..049598598c96d3e8dd503ff2e1a9e0d5803270dc --- /dev/null +++ b/src/quadspi/abr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ABR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ALTERNATER { + bits: u32, +} +impl ALTERNATER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ALTERNATEW<'a> { + w: &'a mut W, +} +impl<'a> _ALTERNATEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - ALTERNATE"] + #[inline] + pub fn alternate(&self) -> ALTERNATER { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + ALTERNATER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - ALTERNATE"] + #[inline] + pub fn alternate(&mut self) -> _ALTERNATEW { + _ALTERNATEW { w: self } + } +} diff --git a/src/quadspi/ar/mod.rs b/src/quadspi/ar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..594b01738cca678da13b08327ec5c7ea65ed1999 --- /dev/null +++ b/src/quadspi/ar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ADDRESSR { + bits: u32, +} +impl ADDRESSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ADDRESSW<'a> { + w: &'a mut W, +} +impl<'a> _ADDRESSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Address"] + #[inline] + pub fn address(&self) -> ADDRESSR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + ADDRESSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Address"] + #[inline] + pub fn address(&mut self) -> _ADDRESSW { + _ADDRESSW { w: self } + } +} diff --git a/src/quadspi/ccr/mod.rs b/src/quadspi/ccr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da6e6526f1630a17e2c32f18f595d8ff168b6670 --- /dev/null +++ b/src/quadspi/ccr/mod.rs @@ -0,0 +1,610 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DDRMR { + bits: bool, +} +impl DDRMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DHHCR { + bits: bool, +} +impl DHHCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SIOOR { + bits: bool, +} +impl SIOOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMODER { + bits: u8, +} +impl FMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMODER { + bits: u8, +} +impl DMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DCYCR { + bits: u8, +} +impl DCYCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ABSIZER { + bits: u8, +} +impl ABSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ABMODER { + bits: u8, +} +impl ABMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADSIZER { + bits: u8, +} +impl ADSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ADMODER { + bits: u8, +} +impl ADMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IMODER { + bits: u8, +} +impl IMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct INSTRUCTIONR { + bits: u8, +} +impl INSTRUCTIONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DDRMW<'a> { + w: &'a mut W, +} +impl<'a> _DDRMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DHHCW<'a> { + w: &'a mut W, +} +impl<'a> _DHHCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SIOOW<'a> { + w: &'a mut W, +} +impl<'a> _SIOOW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FMODEW<'a> { + w: &'a mut W, +} +impl<'a> _FMODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMODEW<'a> { + w: &'a mut W, +} +impl<'a> _DMODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCYCW<'a> { + w: &'a mut W, +} +impl<'a> _DCYCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _ABSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABMODEW<'a> { + w: &'a mut W, +} +impl<'a> _ABMODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _ADSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADMODEW<'a> { + w: &'a mut W, +} +impl<'a> _ADMODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IMODEW<'a> { + w: &'a mut W, +} +impl<'a> _IMODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INSTRUCTIONW<'a> { + w: &'a mut W, +} +impl<'a> _INSTRUCTIONW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Double data rate mode"] + #[inline] + pub fn ddrm(&self) -> DDRMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DDRMR { bits } + } + #[doc = "Bit 30 - DDR hold half cycle"] + #[inline] + pub fn dhhc(&self) -> DHHCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DHHCR { bits } + } + #[doc = "Bit 28 - Send instruction only once mode"] + #[inline] + pub fn sioo(&self) -> SIOOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SIOOR { bits } + } + #[doc = "Bits 26:27 - Functional mode"] + #[inline] + pub fn fmode(&self) -> FMODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FMODER { bits } + } + #[doc = "Bits 24:25 - Data mode"] + #[inline] + pub fn dmode(&self) -> DMODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DMODER { bits } + } + #[doc = "Bits 18:22 - Number of dummy cycles"] + #[inline] + pub fn dcyc(&self) -> DCYCR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DCYCR { bits } + } + #[doc = "Bits 16:17 - Alternate bytes size"] + #[inline] + pub fn absize(&self) -> ABSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ABSIZER { bits } + } + #[doc = "Bits 14:15 - Alternate bytes mode"] + #[inline] + pub fn abmode(&self) -> ABMODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ABMODER { bits } + } + #[doc = "Bits 12:13 - Address size"] + #[inline] + pub fn adsize(&self) -> ADSIZER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADSIZER { bits } + } + #[doc = "Bits 10:11 - Address mode"] + #[inline] + pub fn admode(&self) -> ADMODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADMODER { bits } + } + #[doc = "Bits 8:9 - Instruction mode"] + #[inline] + pub fn imode(&self) -> IMODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IMODER { bits } + } + #[doc = "Bits 0:7 - Instruction"] + #[inline] + pub fn instruction(&self) -> INSTRUCTIONR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + INSTRUCTIONR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Double data rate mode"] + #[inline] + pub fn ddrm(&mut self) -> _DDRMW { + _DDRMW { w: self } + } + #[doc = "Bit 30 - DDR hold half cycle"] + #[inline] + pub fn dhhc(&mut self) -> _DHHCW { + _DHHCW { w: self } + } + #[doc = "Bit 28 - Send instruction only once mode"] + #[inline] + pub fn sioo(&mut self) -> _SIOOW { + _SIOOW { w: self } + } + #[doc = "Bits 26:27 - Functional mode"] + #[inline] + pub fn fmode(&mut self) -> _FMODEW { + _FMODEW { w: self } + } + #[doc = "Bits 24:25 - Data mode"] + #[inline] + pub fn dmode(&mut self) -> _DMODEW { + _DMODEW { w: self } + } + #[doc = "Bits 18:22 - Number of dummy cycles"] + #[inline] + pub fn dcyc(&mut self) -> _DCYCW { + _DCYCW { w: self } + } + #[doc = "Bits 16:17 - Alternate bytes size"] + #[inline] + pub fn absize(&mut self) -> _ABSIZEW { + _ABSIZEW { w: self } + } + #[doc = "Bits 14:15 - Alternate bytes mode"] + #[inline] + pub fn abmode(&mut self) -> _ABMODEW { + _ABMODEW { w: self } + } + #[doc = "Bits 12:13 - Address size"] + #[inline] + pub fn adsize(&mut self) -> _ADSIZEW { + _ADSIZEW { w: self } + } + #[doc = "Bits 10:11 - Address mode"] + #[inline] + pub fn admode(&mut self) -> _ADMODEW { + _ADMODEW { w: self } + } + #[doc = "Bits 8:9 - Instruction mode"] + #[inline] + pub fn imode(&mut self) -> _IMODEW { + _IMODEW { w: self } + } + #[doc = "Bits 0:7 - Instruction"] + #[inline] + pub fn instruction(&mut self) -> _INSTRUCTIONW { + _INSTRUCTIONW { w: self } + } +} diff --git a/src/quadspi/cr/mod.rs b/src/quadspi/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fd22b7c81e291c4bac9bf3e454ac63e1511156a6 --- /dev/null +++ b/src/quadspi/cr/mod.rs @@ -0,0 +1,972 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PRESCALERR { + bits: u8, +} +impl PRESCALERR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PMMR { + bits: bool, +} +impl PMMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct APMSR { + bits: bool, +} +impl APMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOIER { + bits: bool, +} +impl TOIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMIER { + bits: bool, +} +impl SMIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTIER { + bits: bool, +} +impl FTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEIER { + bits: bool, +} +impl TEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHRESR { + bits: u8, +} +impl FTHRESR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FSELR { + bits: bool, +} +impl FSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFMR { + bits: bool, +} +impl DFMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SSHIFTR { + bits: bool, +} +impl SSHIFTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCENR { + bits: bool, +} +impl TCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAENR { + bits: bool, +} +impl DMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ABORTR { + bits: bool, +} +impl ABORTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENR { + bits: bool, +} +impl ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _PRESCALERW<'a> { + w: &'a mut W, +} +impl<'a> _PRESCALERW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PMMW<'a> { + w: &'a mut W, +} +impl<'a> _PMMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _APMSW<'a> { + w: &'a mut W, +} +impl<'a> _APMSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TOIEW<'a> { + w: &'a mut W, +} +impl<'a> _TOIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMIEW<'a> { + w: &'a mut W, +} +impl<'a> _SMIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTIEW<'a> { + w: &'a mut W, +} +impl<'a> _FTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHRESW<'a> { + w: &'a mut W, +} +impl<'a> _FTHRESW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSELW<'a> { + w: &'a mut W, +} +impl<'a> _FSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFMW<'a> { + w: &'a mut W, +} +impl<'a> _DFMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSHIFTW<'a> { + w: &'a mut W, +} +impl<'a> _SSHIFTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCENW<'a> { + w: &'a mut W, +} +impl<'a> _TCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ABORTW<'a> { + w: &'a mut W, +} +impl<'a> _ABORTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENW<'a> { + w: &'a mut W, +} +impl<'a> _ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:31 - Clock prescaler"] + #[inline] + pub fn prescaler(&self) -> PRESCALERR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRESCALERR { bits } + } + #[doc = "Bit 23 - Polling match mode"] + #[inline] + pub fn pmm(&self) -> PMMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PMMR { bits } + } + #[doc = "Bit 22 - Automatic poll mode stop"] + #[inline] + pub fn apms(&self) -> APMSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + APMSR { bits } + } + #[doc = "Bit 20 - TimeOut interrupt enable"] + #[inline] + pub fn toie(&self) -> TOIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOIER { bits } + } + #[doc = "Bit 19 - Status match interrupt enable"] + #[inline] + pub fn smie(&self) -> SMIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMIER { bits } + } + #[doc = "Bit 18 - FIFO threshold interrupt enable"] + #[inline] + pub fn ftie(&self) -> FTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FTIER { bits } + } + #[doc = "Bit 17 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 16 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&self) -> TEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEIER { bits } + } + #[doc = "Bits 8:12 - IFO threshold level"] + #[inline] + pub fn fthres(&self) -> FTHRESR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHRESR { bits } + } + #[doc = "Bit 7 - FLASH memory selection"] + #[inline] + pub fn fsel(&self) -> FSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSELR { bits } + } + #[doc = "Bit 6 - Dual-flash mode"] + #[inline] + pub fn dfm(&self) -> DFMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFMR { bits } + } + #[doc = "Bit 4 - Sample shift"] + #[inline] + pub fn sshift(&self) -> SSHIFTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SSHIFTR { bits } + } + #[doc = "Bit 3 - Timeout counter enable"] + #[inline] + pub fn tcen(&self) -> TCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCENR { bits } + } + #[doc = "Bit 2 - DMA enable"] + #[inline] + pub fn dmaen(&self) -> DMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAENR { bits } + } + #[doc = "Bit 1 - Abort request"] + #[inline] + pub fn abort(&self) -> ABORTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ABORTR { bits } + } + #[doc = "Bit 0 - Enable"] + #[inline] + pub fn en(&self) -> ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:31 - Clock prescaler"] + #[inline] + pub fn prescaler(&mut self) -> _PRESCALERW { + _PRESCALERW { w: self } + } + #[doc = "Bit 23 - Polling match mode"] + #[inline] + pub fn pmm(&mut self) -> _PMMW { + _PMMW { w: self } + } + #[doc = "Bit 22 - Automatic poll mode stop"] + #[inline] + pub fn apms(&mut self) -> _APMSW { + _APMSW { w: self } + } + #[doc = "Bit 20 - TimeOut interrupt enable"] + #[inline] + pub fn toie(&mut self) -> _TOIEW { + _TOIEW { w: self } + } + #[doc = "Bit 19 - Status match interrupt enable"] + #[inline] + pub fn smie(&mut self) -> _SMIEW { + _SMIEW { w: self } + } + #[doc = "Bit 18 - FIFO threshold interrupt enable"] + #[inline] + pub fn ftie(&mut self) -> _FTIEW { + _FTIEW { w: self } + } + #[doc = "Bit 17 - Transfer complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 16 - Transfer error interrupt enable"] + #[inline] + pub fn teie(&mut self) -> _TEIEW { + _TEIEW { w: self } + } + #[doc = "Bits 8:12 - IFO threshold level"] + #[inline] + pub fn fthres(&mut self) -> _FTHRESW { + _FTHRESW { w: self } + } + #[doc = "Bit 7 - FLASH memory selection"] + #[inline] + pub fn fsel(&mut self) -> _FSELW { + _FSELW { w: self } + } + #[doc = "Bit 6 - Dual-flash mode"] + #[inline] + pub fn dfm(&mut self) -> _DFMW { + _DFMW { w: self } + } + #[doc = "Bit 4 - Sample shift"] + #[inline] + pub fn sshift(&mut self) -> _SSHIFTW { + _SSHIFTW { w: self } + } + #[doc = "Bit 3 - Timeout counter enable"] + #[inline] + pub fn tcen(&mut self) -> _TCENW { + _TCENW { w: self } + } + #[doc = "Bit 2 - DMA enable"] + #[inline] + pub fn dmaen(&mut self) -> _DMAENW { + _DMAENW { w: self } + } + #[doc = "Bit 1 - Abort request"] + #[inline] + pub fn abort(&mut self) -> _ABORTW { + _ABORTW { w: self } + } + #[doc = "Bit 0 - Enable"] + #[inline] + pub fn en(&mut self) -> _ENW { + _ENW { w: self } + } +} diff --git a/src/quadspi/dcr/mod.rs b/src/quadspi/dcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0c7189e55253f2eecc0039a7a1c409fd713d4ab4 --- /dev/null +++ b/src/quadspi/dcr/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSIZER { + bits: u8, +} +impl FSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CSHTR { + bits: u8, +} +impl CSHTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKMODER { + bits: bool, +} +impl CKMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _FSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CSHTW<'a> { + w: &'a mut W, +} +impl<'a> _CSHTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKMODEW<'a> { + w: &'a mut W, +} +impl<'a> _CKMODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:20 - FLASH memory size"] + #[inline] + pub fn fsize(&self) -> FSIZER { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSIZER { bits } + } + #[doc = "Bits 8:10 - Chip select high time"] + #[inline] + pub fn csht(&self) -> CSHTR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CSHTR { bits } + } + #[doc = "Bit 0 - Mode 0 / mode 3"] + #[inline] + pub fn ckmode(&self) -> CKMODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKMODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:20 - FLASH memory size"] + #[inline] + pub fn fsize(&mut self) -> _FSIZEW { + _FSIZEW { w: self } + } + #[doc = "Bits 8:10 - Chip select high time"] + #[inline] + pub fn csht(&mut self) -> _CSHTW { + _CSHTW { w: self } + } + #[doc = "Bit 0 - Mode 0 / mode 3"] + #[inline] + pub fn ckmode(&mut self) -> _CKMODEW { + _CKMODEW { w: self } + } +} diff --git a/src/quadspi/dlr/mod.rs b/src/quadspi/dlr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4c35ca66e05cd5eca5c9052259c0f959a7d758c9 --- /dev/null +++ b/src/quadspi/dlr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DLR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DLR { + bits: u32, +} +impl DLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DLW<'a> { + w: &'a mut W, +} +impl<'a> _DLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data length"] + #[inline] + pub fn dl(&self) -> DLR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data length"] + #[inline] + pub fn dl(&mut self) -> _DLW { + _DLW { w: self } + } +} diff --git a/src/quadspi/dr/mod.rs b/src/quadspi/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..566dd994c2b4f213b765d6f15bc3115b058df3ce --- /dev/null +++ b/src/quadspi/dr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATAR { + bits: u32, +} +impl DATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATAW<'a> { + w: &'a mut W, +} +impl<'a> _DATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&self) -> DATAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&mut self) -> _DATAW { + _DATAW { w: self } + } +} diff --git a/src/quadspi/fcr/mod.rs b/src/quadspi/fcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..46fa623d9ba684db2d0ee031f0b0af8193ced7ac --- /dev/null +++ b/src/quadspi/fcr/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CTOFR { + bits: bool, +} +impl CTOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CSMFR { + bits: bool, +} +impl CSMFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTCFR { + bits: bool, +} +impl CTCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTEFR { + bits: bool, +} +impl CTEFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CTOFW<'a> { + w: &'a mut W, +} +impl<'a> _CTOFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CSMFW<'a> { + w: &'a mut W, +} +impl<'a> _CSMFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTCFW<'a> { + w: &'a mut W, +} +impl<'a> _CTCFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTEFW<'a> { + w: &'a mut W, +} +impl<'a> _CTEFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 4 - Clear timeout flag"] + #[inline] + pub fn ctof(&self) -> CTOFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTOFR { bits } + } + #[doc = "Bit 3 - Clear status match flag"] + #[inline] + pub fn csmf(&self) -> CSMFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CSMFR { bits } + } + #[doc = "Bit 1 - Clear transfer complete flag"] + #[inline] + pub fn ctcf(&self) -> CTCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTCFR { bits } + } + #[doc = "Bit 0 - Clear transfer error flag"] + #[inline] + pub fn ctef(&self) -> CTEFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTEFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 4 - Clear timeout flag"] + #[inline] + pub fn ctof(&mut self) -> _CTOFW { + _CTOFW { w: self } + } + #[doc = "Bit 3 - Clear status match flag"] + #[inline] + pub fn csmf(&mut self) -> _CSMFW { + _CSMFW { w: self } + } + #[doc = "Bit 1 - Clear transfer complete flag"] + #[inline] + pub fn ctcf(&mut self) -> _CTCFW { + _CTCFW { w: self } + } + #[doc = "Bit 0 - Clear transfer error flag"] + #[inline] + pub fn ctef(&mut self) -> _CTEFW { + _CTEFW { w: self } + } +} diff --git a/src/quadspi/lptr/mod.rs b/src/quadspi/lptr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2b1f9cd0814489fdae8dcf852d9d99ff50458047 --- /dev/null +++ b/src/quadspi/lptr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::LPTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIMEOUTR { + bits: u16, +} +impl TIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _TIMEOUTW<'a> { + w: &'a mut W, +} +impl<'a> _TIMEOUTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Timeout period"] + #[inline] + pub fn timeout(&self) -> TIMEOUTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + TIMEOUTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Timeout period"] + #[inline] + pub fn timeout(&mut self) -> _TIMEOUTW { + _TIMEOUTW { w: self } + } +} diff --git a/src/quadspi/mod.rs b/src/quadspi/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b8846f419f38cd42e04cff0c8abb6cdfbc93bf80 --- /dev/null +++ b/src/quadspi/mod.rs @@ -0,0 +1,108 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register"] + pub cr: CR, + #[doc = "0x04 - device configuration register"] + pub dcr: DCR, + #[doc = "0x08 - status register"] + pub sr: SR, + #[doc = "0x0c - flag clear register"] + pub fcr: FCR, + #[doc = "0x10 - data length register"] + pub dlr: DLR, + #[doc = "0x14 - communication configuration register"] + pub ccr: CCR, + #[doc = "0x18 - address register"] + pub ar: AR, + #[doc = "0x1c - ABR"] + pub abr: ABR, + #[doc = "0x20 - data register"] + pub dr: DR, + #[doc = "0x24 - polling status mask register"] + pub psmkr: PSMKR, + #[doc = "0x28 - polling status match register"] + pub psmar: PSMAR, + #[doc = "0x2c - polling interval register"] + pub pir: PIR, + #[doc = "0x30 - low-power timeout register"] + pub lptr: LPTR, +} +#[doc = "control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register"] +pub mod cr; +#[doc = "device configuration register"] +pub struct DCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "device configuration register"] +pub mod dcr; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "flag clear register"] +pub struct FCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "flag clear register"] +pub mod fcr; +#[doc = "data length register"] +pub struct DLR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data length register"] +pub mod dlr; +#[doc = "communication configuration register"] +pub struct CCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "communication configuration register"] +pub mod ccr; +#[doc = "address register"] +pub struct AR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "address register"] +pub mod ar; +#[doc = "ABR"] +pub struct ABR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "ABR"] +pub mod abr; +#[doc = "data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register"] +pub mod dr; +#[doc = "polling status mask register"] +pub struct PSMKR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "polling status mask register"] +pub mod psmkr; +#[doc = "polling status match register"] +pub struct PSMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "polling status match register"] +pub mod psmar; +#[doc = "polling interval register"] +pub struct PIR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "polling interval register"] +pub mod pir; +#[doc = "low-power timeout register"] +pub struct LPTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "low-power timeout register"] +pub mod lptr; diff --git a/src/quadspi/pir/mod.rs b/src/quadspi/pir/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6845d8f63a9c0213d42d17f003e80356be07e300 --- /dev/null +++ b/src/quadspi/pir/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PIR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct INTERVALR { + bits: u16, +} +impl INTERVALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _INTERVALW<'a> { + w: &'a mut W, +} +impl<'a> _INTERVALW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Polling interval"] + #[inline] + pub fn interval(&self) -> INTERVALR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INTERVALR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Polling interval"] + #[inline] + pub fn interval(&mut self) -> _INTERVALW { + _INTERVALW { w: self } + } +} diff --git a/src/quadspi/psmar/mod.rs b/src/quadspi/psmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7db05b2dffe436d819c010c704777e9808d6033c --- /dev/null +++ b/src/quadspi/psmar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MATCHR { + bits: u32, +} +impl MATCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MATCHW<'a> { + w: &'a mut W, +} +impl<'a> _MATCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Status match"] + #[inline] + pub fn match_(&self) -> MATCHR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + MATCHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Status match"] + #[inline] + pub fn match_(&mut self) -> _MATCHW { + _MATCHW { w: self } + } +} diff --git a/src/quadspi/psmkr/mod.rs b/src/quadspi/psmkr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..60448358dcb5e2627cd63a532fe5a225d9d1f283 --- /dev/null +++ b/src/quadspi/psmkr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSMKR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MASKR { + bits: u32, +} +impl MASKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MASKW<'a> { + w: &'a mut W, +} +impl<'a> _MASKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Status mask"] + #[inline] + pub fn mask(&self) -> MASKR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + MASKR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Status mask"] + #[inline] + pub fn mask(&mut self) -> _MASKW { + _MASKW { w: self } + } +} diff --git a/src/quadspi/sr/mod.rs b/src/quadspi/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4cf2a46cfa9d4418d614db6c6b62fc8882adf99f --- /dev/null +++ b/src/quadspi/sr/mod.rs @@ -0,0 +1,227 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::SR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct FLEVELR { + bits: u8, +} +impl FLEVELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BUSYR { + bits: bool, +} +impl BUSYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TOFR { + bits: bool, +} +impl TOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SMFR { + bits: bool, +} +impl SMFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTFR { + bits: bool, +} +impl FTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCFR { + bits: bool, +} +impl TCFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TEFR { + bits: bool, +} +impl TEFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:14 - FIFO level"] + #[inline] + pub fn flevel(&self) -> FLEVELR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FLEVELR { bits } + } + #[doc = "Bit 5 - Busy"] + #[inline] + pub fn busy(&self) -> BUSYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BUSYR { bits } + } + #[doc = "Bit 4 - Timeout flag"] + #[inline] + pub fn tof(&self) -> TOFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TOFR { bits } + } + #[doc = "Bit 3 - Status match flag"] + #[inline] + pub fn smf(&self) -> SMFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SMFR { bits } + } + #[doc = "Bit 2 - FIFO threshold flag"] + #[inline] + pub fn ftf(&self) -> FTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FTFR { bits } + } + #[doc = "Bit 1 - Transfer complete flag"] + #[inline] + pub fn tcf(&self) -> TCFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCFR { bits } + } + #[doc = "Bit 0 - Transfer error flag"] + #[inline] + pub fn tef(&self) -> TEFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TEFR { bits } + } +} diff --git a/src/rcc/ahb1enr/mod.rs b/src/rcc/ahb1enr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4a9f3a7554031ea8acdfff8be32e6ba97816221f --- /dev/null +++ b/src/rcc/ahb1enr/mod.rs @@ -0,0 +1,713 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB1ENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct GPIOAENR { + bits: bool, +} +impl GPIOAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOBENR { + bits: bool, +} +impl GPIOBENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOCENR { + bits: bool, +} +impl GPIOCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIODENR { + bits: bool, +} +impl GPIODENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOEENR { + bits: bool, +} +impl GPIOEENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOFENR { + bits: bool, +} +impl GPIOFENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOGENR { + bits: bool, +} +impl GPIOGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOHENR { + bits: bool, +} +impl GPIOHENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCENR { + bits: bool, +} +impl CRCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA1ENR { + bits: bool, +} +impl DMA1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA2ENR { + bits: bool, +} +impl DMA2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _GPIOAENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOBENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOBENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOCENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIODENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIODENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOEENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOEENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOFENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOFENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOGENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOHENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOHENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRCENW<'a> { + w: &'a mut W, +} +impl<'a> _CRCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA1ENW<'a> { + w: &'a mut W, +} +impl<'a> _DMA1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA2ENW<'a> { + w: &'a mut W, +} +impl<'a> _DMA2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - IO port A clock enable"] + #[inline] + pub fn gpioaen(&self) -> GPIOAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOAENR { bits } + } + #[doc = "Bit 1 - IO port B clock enable"] + #[inline] + pub fn gpioben(&self) -> GPIOBENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOBENR { bits } + } + #[doc = "Bit 2 - IO port C clock enable"] + #[inline] + pub fn gpiocen(&self) -> GPIOCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOCENR { bits } + } + #[doc = "Bit 3 - IO port D clock enable"] + #[inline] + pub fn gpioden(&self) -> GPIODENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIODENR { bits } + } + #[doc = "Bit 4 - IO port E clock enable"] + #[inline] + pub fn gpioeen(&self) -> GPIOEENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOEENR { bits } + } + #[doc = "Bit 5 - IO port F clock enable"] + #[inline] + pub fn gpiofen(&self) -> GPIOFENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOFENR { bits } + } + #[doc = "Bit 6 - IO port G clock enable"] + #[inline] + pub fn gpiogen(&self) -> GPIOGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOGENR { bits } + } + #[doc = "Bit 7 - IO port H clock enable"] + #[inline] + pub fn gpiohen(&self) -> GPIOHENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOHENR { bits } + } + #[doc = "Bit 12 - CRC clock enable"] + #[inline] + pub fn crcen(&self) -> CRCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCENR { bits } + } + #[doc = "Bit 21 - DMA1 clock enable"] + #[inline] + pub fn dma1en(&self) -> DMA1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA1ENR { bits } + } + #[doc = "Bit 22 - DMA2 clock enable"] + #[inline] + pub fn dma2en(&self) -> DMA2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA2ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 1048576 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - IO port A clock enable"] + #[inline] + pub fn gpioaen(&mut self) -> _GPIOAENW { + _GPIOAENW { w: self } + } + #[doc = "Bit 1 - IO port B clock enable"] + #[inline] + pub fn gpioben(&mut self) -> _GPIOBENW { + _GPIOBENW { w: self } + } + #[doc = "Bit 2 - IO port C clock enable"] + #[inline] + pub fn gpiocen(&mut self) -> _GPIOCENW { + _GPIOCENW { w: self } + } + #[doc = "Bit 3 - IO port D clock enable"] + #[inline] + pub fn gpioden(&mut self) -> _GPIODENW { + _GPIODENW { w: self } + } + #[doc = "Bit 4 - IO port E clock enable"] + #[inline] + pub fn gpioeen(&mut self) -> _GPIOEENW { + _GPIOEENW { w: self } + } + #[doc = "Bit 5 - IO port F clock enable"] + #[inline] + pub fn gpiofen(&mut self) -> _GPIOFENW { + _GPIOFENW { w: self } + } + #[doc = "Bit 6 - IO port G clock enable"] + #[inline] + pub fn gpiogen(&mut self) -> _GPIOGENW { + _GPIOGENW { w: self } + } + #[doc = "Bit 7 - IO port H clock enable"] + #[inline] + pub fn gpiohen(&mut self) -> _GPIOHENW { + _GPIOHENW { w: self } + } + #[doc = "Bit 12 - CRC clock enable"] + #[inline] + pub fn crcen(&mut self) -> _CRCENW { + _CRCENW { w: self } + } + #[doc = "Bit 21 - DMA1 clock enable"] + #[inline] + pub fn dma1en(&mut self) -> _DMA1ENW { + _DMA1ENW { w: self } + } + #[doc = "Bit 22 - DMA2 clock enable"] + #[inline] + pub fn dma2en(&mut self) -> _DMA2ENW { + _DMA2ENW { w: self } + } +} diff --git a/src/rcc/ahb1lpenr/mod.rs b/src/rcc/ahb1lpenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9586fda4e412d5deb49cc128a82fc574bc0e1b3a --- /dev/null +++ b/src/rcc/ahb1lpenr/mod.rs @@ -0,0 +1,890 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB1LPENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct GPIOALPENR { + bits: bool, +} +impl GPIOALPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOBLPENR { + bits: bool, +} +impl GPIOBLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOCLPENR { + bits: bool, +} +impl GPIOCLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIODLPENR { + bits: bool, +} +impl GPIODLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOELPENR { + bits: bool, +} +impl GPIOELPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOFLPENR { + bits: bool, +} +impl GPIOFLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOGLPENR { + bits: bool, +} +impl GPIOGLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOHLPENR { + bits: bool, +} +impl GPIOHLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCLPENR { + bits: bool, +} +impl CRCLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FLITFLPENR { + bits: bool, +} +impl FLITFLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRAM1LPENR { + bits: bool, +} +impl SRAM1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA1LPENR { + bits: bool, +} +impl DMA1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA2LPENR { + bits: bool, +} +impl DMA2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRAM2LPENR { + bits: bool, +} +impl SRAM2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _GPIOALPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOALPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOBLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOBLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOCLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOCLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIODLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIODLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOELPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOELPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOFLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOFLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOGLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOGLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOHLPENW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOHLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRCLPENW<'a> { + w: &'a mut W, +} +impl<'a> _CRCLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FLITFLPENW<'a> { + w: &'a mut W, +} +impl<'a> _FLITFLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRAM1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SRAM1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _DMA1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _DMA2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRAM2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SRAM2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - IO port A clock enable during sleep mode"] + #[inline] + pub fn gpioalpen(&self) -> GPIOALPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOALPENR { bits } + } + #[doc = "Bit 1 - IO port B clock enable during Sleep mode"] + #[inline] + pub fn gpioblpen(&self) -> GPIOBLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOBLPENR { bits } + } + #[doc = "Bit 2 - IO port C clock enable during Sleep mode"] + #[inline] + pub fn gpioclpen(&self) -> GPIOCLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOCLPENR { bits } + } + #[doc = "Bit 3 - IO port D clock enable during Sleep mode"] + #[inline] + pub fn gpiodlpen(&self) -> GPIODLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIODLPENR { bits } + } + #[doc = "Bit 4 - IO port E clock enable during Sleep mode"] + #[inline] + pub fn gpioelpen(&self) -> GPIOELPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOELPENR { bits } + } + #[doc = "Bit 5 - IO port F clock enable during sleep mode"] + #[inline] + pub fn gpioflpen(&self) -> GPIOFLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOFLPENR { bits } + } + #[doc = "Bit 6 - IO port G clock enable during sleep mode"] + #[inline] + pub fn gpioglpen(&self) -> GPIOGLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOGLPENR { bits } + } + #[doc = "Bit 7 - IO port H clock enable during Sleep mode"] + #[inline] + pub fn gpiohlpen(&self) -> GPIOHLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOHLPENR { bits } + } + #[doc = "Bit 12 - CRC clock enable during Sleep mode"] + #[inline] + pub fn crclpen(&self) -> CRCLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCLPENR { bits } + } + #[doc = "Bit 15 - Flash interface clock enable during Sleep mode"] + #[inline] + pub fn flitflpen(&self) -> FLITFLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FLITFLPENR { bits } + } + #[doc = "Bit 16 - SRAM 1interface clock enable during Sleep mode"] + #[inline] + pub fn sram1lpen(&self) -> SRAM1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRAM1LPENR { bits } + } + #[doc = "Bit 21 - DMA1 clock enable during Sleep mode"] + #[inline] + pub fn dma1lpen(&self) -> DMA1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA1LPENR { bits } + } + #[doc = "Bit 22 - DMA2 clock enable during Sleep mode"] + #[inline] + pub fn dma2lpen(&self) -> DMA2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA2LPENR { bits } + } + #[doc = "Bit 17 - SRAM2interface clock enable during Sleep mode"] + #[inline] + pub fn sram2lpen(&self) -> SRAM2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRAM2LPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 2120716799 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - IO port A clock enable during sleep mode"] + #[inline] + pub fn gpioalpen(&mut self) -> _GPIOALPENW { + _GPIOALPENW { w: self } + } + #[doc = "Bit 1 - IO port B clock enable during Sleep mode"] + #[inline] + pub fn gpioblpen(&mut self) -> _GPIOBLPENW { + _GPIOBLPENW { w: self } + } + #[doc = "Bit 2 - IO port C clock enable during Sleep mode"] + #[inline] + pub fn gpioclpen(&mut self) -> _GPIOCLPENW { + _GPIOCLPENW { w: self } + } + #[doc = "Bit 3 - IO port D clock enable during Sleep mode"] + #[inline] + pub fn gpiodlpen(&mut self) -> _GPIODLPENW { + _GPIODLPENW { w: self } + } + #[doc = "Bit 4 - IO port E clock enable during Sleep mode"] + #[inline] + pub fn gpioelpen(&mut self) -> _GPIOELPENW { + _GPIOELPENW { w: self } + } + #[doc = "Bit 5 - IO port F clock enable during sleep mode"] + #[inline] + pub fn gpioflpen(&mut self) -> _GPIOFLPENW { + _GPIOFLPENW { w: self } + } + #[doc = "Bit 6 - IO port G clock enable during sleep mode"] + #[inline] + pub fn gpioglpen(&mut self) -> _GPIOGLPENW { + _GPIOGLPENW { w: self } + } + #[doc = "Bit 7 - IO port H clock enable during Sleep mode"] + #[inline] + pub fn gpiohlpen(&mut self) -> _GPIOHLPENW { + _GPIOHLPENW { w: self } + } + #[doc = "Bit 12 - CRC clock enable during Sleep mode"] + #[inline] + pub fn crclpen(&mut self) -> _CRCLPENW { + _CRCLPENW { w: self } + } + #[doc = "Bit 15 - Flash interface clock enable during Sleep mode"] + #[inline] + pub fn flitflpen(&mut self) -> _FLITFLPENW { + _FLITFLPENW { w: self } + } + #[doc = "Bit 16 - SRAM 1interface clock enable during Sleep mode"] + #[inline] + pub fn sram1lpen(&mut self) -> _SRAM1LPENW { + _SRAM1LPENW { w: self } + } + #[doc = "Bit 21 - DMA1 clock enable during Sleep mode"] + #[inline] + pub fn dma1lpen(&mut self) -> _DMA1LPENW { + _DMA1LPENW { w: self } + } + #[doc = "Bit 22 - DMA2 clock enable during Sleep mode"] + #[inline] + pub fn dma2lpen(&mut self) -> _DMA2LPENW { + _DMA2LPENW { w: self } + } + #[doc = "Bit 17 - SRAM2interface clock enable during Sleep mode"] + #[inline] + pub fn sram2lpen(&mut self) -> _SRAM2LPENW { + _SRAM2LPENW { w: self } + } +} diff --git a/src/rcc/ahb1rstr/mod.rs b/src/rcc/ahb1rstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..73ab1223b9bc1bb79f4a8fba3ab5325f77b8ac9f --- /dev/null +++ b/src/rcc/ahb1rstr/mod.rs @@ -0,0 +1,713 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB1RSTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct GPIOARSTR { + bits: bool, +} +impl GPIOARSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOBRSTR { + bits: bool, +} +impl GPIOBRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOCRSTR { + bits: bool, +} +impl GPIOCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIODRSTR { + bits: bool, +} +impl GPIODRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOERSTR { + bits: bool, +} +impl GPIOERSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOFRSTR { + bits: bool, +} +impl GPIOFRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOGRSTR { + bits: bool, +} +impl GPIOGRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct GPIOHRSTR { + bits: bool, +} +impl GPIOHRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRCRSTR { + bits: bool, +} +impl CRCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA1RSTR { + bits: bool, +} +impl DMA1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMA2RSTR { + bits: bool, +} +impl DMA2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _GPIOARSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOARSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOBRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOBRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIODRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIODRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOERSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOERSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOFRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOFRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOGRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOGRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _GPIOHRSTW<'a> { + w: &'a mut W, +} +impl<'a> _GPIOHRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _CRCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _DMA1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMA2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _DMA2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - IO port A reset"] + #[inline] + pub fn gpioarst(&self) -> GPIOARSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOARSTR { bits } + } + #[doc = "Bit 1 - IO port B reset"] + #[inline] + pub fn gpiobrst(&self) -> GPIOBRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOBRSTR { bits } + } + #[doc = "Bit 2 - IO port C reset"] + #[inline] + pub fn gpiocrst(&self) -> GPIOCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOCRSTR { bits } + } + #[doc = "Bit 3 - IO port D reset"] + #[inline] + pub fn gpiodrst(&self) -> GPIODRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIODRSTR { bits } + } + #[doc = "Bit 4 - IO port E reset"] + #[inline] + pub fn gpioerst(&self) -> GPIOERSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOERSTR { bits } + } + #[doc = "Bit 5 - IO port F reset"] + #[inline] + pub fn gpiofrst(&self) -> GPIOFRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOFRSTR { bits } + } + #[doc = "Bit 6 - IO port G reset"] + #[inline] + pub fn gpiogrst(&self) -> GPIOGRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOGRSTR { bits } + } + #[doc = "Bit 7 - IO port H reset"] + #[inline] + pub fn gpiohrst(&self) -> GPIOHRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + GPIOHRSTR { bits } + } + #[doc = "Bit 12 - CRC reset"] + #[inline] + pub fn crcrst(&self) -> CRCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRCRSTR { bits } + } + #[doc = "Bit 21 - DMA2 reset"] + #[inline] + pub fn dma1rst(&self) -> DMA1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA1RSTR { bits } + } + #[doc = "Bit 22 - DMA2 reset"] + #[inline] + pub fn dma2rst(&self) -> DMA2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMA2RSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - IO port A reset"] + #[inline] + pub fn gpioarst(&mut self) -> _GPIOARSTW { + _GPIOARSTW { w: self } + } + #[doc = "Bit 1 - IO port B reset"] + #[inline] + pub fn gpiobrst(&mut self) -> _GPIOBRSTW { + _GPIOBRSTW { w: self } + } + #[doc = "Bit 2 - IO port C reset"] + #[inline] + pub fn gpiocrst(&mut self) -> _GPIOCRSTW { + _GPIOCRSTW { w: self } + } + #[doc = "Bit 3 - IO port D reset"] + #[inline] + pub fn gpiodrst(&mut self) -> _GPIODRSTW { + _GPIODRSTW { w: self } + } + #[doc = "Bit 4 - IO port E reset"] + #[inline] + pub fn gpioerst(&mut self) -> _GPIOERSTW { + _GPIOERSTW { w: self } + } + #[doc = "Bit 5 - IO port F reset"] + #[inline] + pub fn gpiofrst(&mut self) -> _GPIOFRSTW { + _GPIOFRSTW { w: self } + } + #[doc = "Bit 6 - IO port G reset"] + #[inline] + pub fn gpiogrst(&mut self) -> _GPIOGRSTW { + _GPIOGRSTW { w: self } + } + #[doc = "Bit 7 - IO port H reset"] + #[inline] + pub fn gpiohrst(&mut self) -> _GPIOHRSTW { + _GPIOHRSTW { w: self } + } + #[doc = "Bit 12 - CRC reset"] + #[inline] + pub fn crcrst(&mut self) -> _CRCRSTW { + _CRCRSTW { w: self } + } + #[doc = "Bit 21 - DMA2 reset"] + #[inline] + pub fn dma1rst(&mut self) -> _DMA1RSTW { + _DMA1RSTW { w: self } + } + #[doc = "Bit 22 - DMA2 reset"] + #[inline] + pub fn dma2rst(&mut self) -> _DMA2RSTW { + _DMA2RSTW { w: self } + } +} diff --git a/src/rcc/ahb2enr/mod.rs b/src/rcc/ahb2enr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c1595d4a046b71f7764ea6675e0ca140821fc173 --- /dev/null +++ b/src/rcc/ahb2enr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB2ENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OTGFSENR { + bits: bool, +} +impl OTGFSENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RNGENR { + bits: bool, +} +impl RNGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRYPENR { + bits: bool, +} +impl CRYPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OTGFSENW<'a> { + w: &'a mut W, +} +impl<'a> _OTGFSENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RNGENW<'a> { + w: &'a mut W, +} +impl<'a> _RNGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRYPENW<'a> { + w: &'a mut W, +} +impl<'a> _CRYPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - USB OTG FS clock enable"] + #[inline] + pub fn otgfsen(&self) -> OTGFSENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTGFSENR { bits } + } + #[doc = "Bit 6 - RNGEN"] + #[inline] + pub fn rngen(&self) -> RNGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RNGENR { bits } + } + #[doc = "Bit 4 - CRYP clock enable"] + #[inline] + pub fn crypen(&self) -> CRYPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRYPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - USB OTG FS clock enable"] + #[inline] + pub fn otgfsen(&mut self) -> _OTGFSENW { + _OTGFSENW { w: self } + } + #[doc = "Bit 6 - RNGEN"] + #[inline] + pub fn rngen(&mut self) -> _RNGENW { + _RNGENW { w: self } + } + #[doc = "Bit 4 - CRYP clock enable"] + #[inline] + pub fn crypen(&mut self) -> _CRYPENW { + _CRYPENW { w: self } + } +} diff --git a/src/rcc/ahb2lpenr/mod.rs b/src/rcc/ahb2lpenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..576c77e59797fff514f1158b4be2f0d6af8f5846 --- /dev/null +++ b/src/rcc/ahb2lpenr/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB2LPENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OTGFSLPENR { + bits: bool, +} +impl OTGFSLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RNGLPENR { + bits: bool, +} +impl RNGLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSMCLPENR { + bits: bool, +} +impl FSMCLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct QSPILPENR { + bits: bool, +} +impl QSPILPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OTGFSLPENW<'a> { + w: &'a mut W, +} +impl<'a> _OTGFSLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RNGLPENW<'a> { + w: &'a mut W, +} +impl<'a> _RNGLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSMCLPENW<'a> { + w: &'a mut W, +} +impl<'a> _FSMCLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _QSPILPENW<'a> { + w: &'a mut W, +} +impl<'a> _QSPILPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - USB OTG FS clock enable during Sleep mode"] + #[inline] + pub fn otgfslpen(&self) -> OTGFSLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTGFSLPENR { bits } + } + #[doc = "Bit 6 - RNGLPEN"] + #[inline] + pub fn rnglpen(&self) -> RNGLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RNGLPENR { bits } + } + #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"] + #[inline] + pub fn fsmclpen(&self) -> FSMCLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSMCLPENR { bits } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"] + #[inline] + pub fn qspilpen(&self) -> QSPILPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + QSPILPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 241 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - USB OTG FS clock enable during Sleep mode"] + #[inline] + pub fn otgfslpen(&mut self) -> _OTGFSLPENW { + _OTGFSLPENW { w: self } + } + #[doc = "Bit 6 - RNGLPEN"] + #[inline] + pub fn rnglpen(&mut self) -> _RNGLPENW { + _RNGLPENW { w: self } + } + #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"] + #[inline] + pub fn fsmclpen(&mut self) -> _FSMCLPENW { + _FSMCLPENW { w: self } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"] + #[inline] + pub fn qspilpen(&mut self) -> _QSPILPENW { + _QSPILPENW { w: self } + } +} diff --git a/src/rcc/ahb2rstr/mod.rs b/src/rcc/ahb2rstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4b2e53d2684916df41e5df5278f5db4a1b8185f6 --- /dev/null +++ b/src/rcc/ahb2rstr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB2RSTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OTGFSRSTR { + bits: bool, +} +impl OTGFSRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RNGRSTR { + bits: bool, +} +impl RNGRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CRYPRSTR { + bits: bool, +} +impl CRYPRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OTGFSRSTW<'a> { + w: &'a mut W, +} +impl<'a> _OTGFSRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RNGRSTW<'a> { + w: &'a mut W, +} +impl<'a> _RNGRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CRYPRSTW<'a> { + w: &'a mut W, +} +impl<'a> _CRYPRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - USB OTG FS module reset"] + #[inline] + pub fn otgfsrst(&self) -> OTGFSRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OTGFSRSTR { bits } + } + #[doc = "Bit 6 - RNGRST"] + #[inline] + pub fn rngrst(&self) -> RNGRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RNGRSTR { bits } + } + #[doc = "Bit 4 - CRYP module reset"] + #[inline] + pub fn cryprst(&self) -> CRYPRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CRYPRSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - USB OTG FS module reset"] + #[inline] + pub fn otgfsrst(&mut self) -> _OTGFSRSTW { + _OTGFSRSTW { w: self } + } + #[doc = "Bit 6 - RNGRST"] + #[inline] + pub fn rngrst(&mut self) -> _RNGRSTW { + _RNGRSTW { w: self } + } + #[doc = "Bit 4 - CRYP module reset"] + #[inline] + pub fn cryprst(&mut self) -> _CRYPRSTW { + _CRYPRSTW { w: self } + } +} diff --git a/src/rcc/ahb3enr/mod.rs b/src/rcc/ahb3enr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..79d8bb51bfb2ee9a0e8099d68ce4eba099201339 --- /dev/null +++ b/src/rcc/ahb3enr/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB3ENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSMCENR { + bits: bool, +} +impl FSMCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct QSPIENR { + bits: bool, +} +impl QSPIENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSMCENW<'a> { + w: &'a mut W, +} +impl<'a> _FSMCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _QSPIENW<'a> { + w: &'a mut W, +} +impl<'a> _QSPIENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Flexible memory controller module clock enable"] + #[inline] + pub fn fsmcen(&self) -> FSMCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSMCENR { bits } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable"] + #[inline] + pub fn qspien(&self) -> QSPIENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + QSPIENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Flexible memory controller module clock enable"] + #[inline] + pub fn fsmcen(&mut self) -> _FSMCENW { + _FSMCENW { w: self } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable"] + #[inline] + pub fn qspien(&mut self) -> _QSPIENW { + _QSPIENW { w: self } + } +} diff --git a/src/rcc/ahb3lpenr/mod.rs b/src/rcc/ahb3lpenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..97e9bcdbe36f241e2d2521057957cfacf81ba798 --- /dev/null +++ b/src/rcc/ahb3lpenr/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB3LPENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSMCLPENR { + bits: bool, +} +impl FSMCLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct QSPILPENR { + bits: bool, +} +impl QSPILPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSMCLPENW<'a> { + w: &'a mut W, +} +impl<'a> _FSMCLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _QSPILPENW<'a> { + w: &'a mut W, +} +impl<'a> _QSPILPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"] + #[inline] + pub fn fsmclpen(&self) -> FSMCLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSMCLPENR { bits } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"] + #[inline] + pub fn qspilpen(&self) -> QSPILPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + QSPILPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 3 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Flexible memory controller module clock enable during Sleep mode"] + #[inline] + pub fn fsmclpen(&mut self) -> _FSMCLPENW { + _FSMCLPENW { w: self } + } + #[doc = "Bit 1 - QUADSPI memory controller module clock enable during Sleep mode"] + #[inline] + pub fn qspilpen(&mut self) -> _QSPILPENW { + _QSPILPENW { w: self } + } +} diff --git a/src/rcc/ahb3rstr/mod.rs b/src/rcc/ahb3rstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..99913229cf22d5339486c0a0b07fa20d3abee7f0 --- /dev/null +++ b/src/rcc/ahb3rstr/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AHB3RSTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSMCRSTR { + bits: bool, +} +impl FSMCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct QSPIRSTR { + bits: bool, +} +impl QSPIRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FSMCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _FSMCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _QSPIRSTW<'a> { + w: &'a mut W, +} +impl<'a> _QSPIRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Flexible memory controller module reset"] + #[inline] + pub fn fsmcrst(&self) -> FSMCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSMCRSTR { bits } + } + #[doc = "Bit 1 - QUADSPI module reset"] + #[inline] + pub fn qspirst(&self) -> QSPIRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + QSPIRSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Flexible memory controller module reset"] + #[inline] + pub fn fsmcrst(&mut self) -> _FSMCRSTW { + _FSMCRSTW { w: self } + } + #[doc = "Bit 1 - QUADSPI module reset"] + #[inline] + pub fn qspirst(&mut self) -> _QSPIRSTW { + _QSPIRSTW { w: self } + } +} diff --git a/src/rcc/apb1enr/mod.rs b/src/rcc/apb1enr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a75c64c4ee731b53afc765fc0612e6778e5a2c33 --- /dev/null +++ b/src/rcc/apb1enr/mod.rs @@ -0,0 +1,1775 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB1ENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM2ENR { + bits: bool, +} +impl TIM2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM3ENR { + bits: bool, +} +impl TIM3ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM4ENR { + bits: bool, +} +impl TIM4ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM5ENR { + bits: bool, +} +impl TIM5ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM6ENR { + bits: bool, +} +impl TIM6ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM7ENR { + bits: bool, +} +impl TIM7ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM12ENR { + bits: bool, +} +impl TIM12ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM13ENR { + bits: bool, +} +impl TIM13ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM14ENR { + bits: bool, +} +impl TIM14ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WWDGENR { + bits: bool, +} +impl WWDGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI2ENR { + bits: bool, +} +impl SPI2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI3ENR { + bits: bool, +} +impl SPI3ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART2ENR { + bits: bool, +} +impl USART2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART3ENR { + bits: bool, +} +impl USART3ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C1ENR { + bits: bool, +} +impl I2C1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C2ENR { + bits: bool, +} +impl I2C2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C3ENR { + bits: bool, +} +impl I2C3ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C4ENR { + bits: bool, +} +impl I2C4ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN1ENR { + bits: bool, +} +impl CAN1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN2ENR { + bits: bool, +} +impl CAN2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWRENR { + bits: bool, +} +impl PWRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LPTIMER1ENR { + bits: bool, +} +impl LPTIMER1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTCAPBR { + bits: bool, +} +impl RTCAPBR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART4ENR { + bits: bool, +} +impl UART4ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART5ENR { + bits: bool, +} +impl UART5ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN3ENR { + bits: bool, +} +impl CAN3ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DACENR { + bits: bool, +} +impl DACENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART7ENR { + bits: bool, +} +impl UART7ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART8ENR { + bits: bool, +} +impl UART8ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM2ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM3ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM3ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM4ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM4ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM5ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM5ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM6ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM6ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM7ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM7ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM12ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM12ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM13ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM13ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM14ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM14ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WWDGENW<'a> { + w: &'a mut W, +} +impl<'a> _WWDGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI2ENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI3ENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI3ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART2ENW<'a> { + w: &'a mut W, +} +impl<'a> _USART2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART3ENW<'a> { + w: &'a mut W, +} +impl<'a> _USART3ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C1ENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C2ENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C3ENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C3ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C4ENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C4ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN1ENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN2ENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWRENW<'a> { + w: &'a mut W, +} +impl<'a> _PWRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LPTIMER1ENW<'a> { + w: &'a mut W, +} +impl<'a> _LPTIMER1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCAPBW<'a> { + w: &'a mut W, +} +impl<'a> _RTCAPBW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART4ENW<'a> { + w: &'a mut W, +} +impl<'a> _UART4ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART5ENW<'a> { + w: &'a mut W, +} +impl<'a> _UART5ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN3ENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN3ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACENW<'a> { + w: &'a mut W, +} +impl<'a> _DACENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART7ENW<'a> { + w: &'a mut W, +} +impl<'a> _UART7ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART8ENW<'a> { + w: &'a mut W, +} +impl<'a> _UART8ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM2 clock enable"] + #[inline] + pub fn tim2en(&self) -> TIM2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM2ENR { bits } + } + #[doc = "Bit 1 - TIM3 clock enable"] + #[inline] + pub fn tim3en(&self) -> TIM3ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM3ENR { bits } + } + #[doc = "Bit 2 - TIM4 clock enable"] + #[inline] + pub fn tim4en(&self) -> TIM4ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM4ENR { bits } + } + #[doc = "Bit 3 - TIM5 clock enable"] + #[inline] + pub fn tim5en(&self) -> TIM5ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM5ENR { bits } + } + #[doc = "Bit 4 - TIM6EN"] + #[inline] + pub fn tim6en(&self) -> TIM6ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM6ENR { bits } + } + #[doc = "Bit 5 - TIM7EN"] + #[inline] + pub fn tim7en(&self) -> TIM7ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM7ENR { bits } + } + #[doc = "Bit 6 - TIM12EN"] + #[inline] + pub fn tim12en(&self) -> TIM12ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM12ENR { bits } + } + #[doc = "Bit 7 - TIM13EN"] + #[inline] + pub fn tim13en(&self) -> TIM13ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM13ENR { bits } + } + #[doc = "Bit 8 - TIM14EN"] + #[inline] + pub fn tim14en(&self) -> TIM14ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM14ENR { bits } + } + #[doc = "Bit 11 - Window watchdog clock enable"] + #[inline] + pub fn wwdgen(&self) -> WWDGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WWDGENR { bits } + } + #[doc = "Bit 14 - SPI2 clock enable"] + #[inline] + pub fn spi2en(&self) -> SPI2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI2ENR { bits } + } + #[doc = "Bit 15 - SPI3 clock enable"] + #[inline] + pub fn spi3en(&self) -> SPI3ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI3ENR { bits } + } + #[doc = "Bit 17 - USART 2 clock enable"] + #[inline] + pub fn usart2en(&self) -> USART2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART2ENR { bits } + } + #[doc = "Bit 18 - USART3EN"] + #[inline] + pub fn usart3en(&self) -> USART3ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART3ENR { bits } + } + #[doc = "Bit 21 - I2C1 clock enable"] + #[inline] + pub fn i2c1en(&self) -> I2C1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C1ENR { bits } + } + #[doc = "Bit 22 - I2C2 clock enable"] + #[inline] + pub fn i2c2en(&self) -> I2C2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C2ENR { bits } + } + #[doc = "Bit 23 - I2C3 clock enable"] + #[inline] + pub fn i2c3en(&self) -> I2C3ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C3ENR { bits } + } + #[doc = "Bit 24 - I2C4EN"] + #[inline] + pub fn i2c4en(&self) -> I2C4ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C4ENR { bits } + } + #[doc = "Bit 25 - CAN1EN"] + #[inline] + pub fn can1en(&self) -> CAN1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN1ENR { bits } + } + #[doc = "Bit 26 - CAN2EN"] + #[inline] + pub fn can2en(&self) -> CAN2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN2ENR { bits } + } + #[doc = "Bit 28 - Power interface clock enable"] + #[inline] + pub fn pwren(&self) -> PWRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWRENR { bits } + } + #[doc = "Bit 9 - LPTimer 1 clock enable"] + #[inline] + pub fn lptimer1en(&self) -> LPTIMER1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LPTIMER1ENR { bits } + } + #[doc = "Bit 10 - clock enable"] + #[inline] + pub fn rtcapb(&self) -> RTCAPBR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTCAPBR { bits } + } + #[doc = "Bit 19 - UART 4 clock enable"] + #[inline] + pub fn uart4en(&self) -> UART4ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART4ENR { bits } + } + #[doc = "Bit 20 - UART 5 clock enable"] + #[inline] + pub fn uart5en(&self) -> UART5ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART5ENR { bits } + } + #[doc = "Bit 27 - CAN 3 clock enable"] + #[inline] + pub fn can3en(&self) -> CAN3ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN3ENR { bits } + } + #[doc = "Bit 29 - DAC clock enable"] + #[inline] + pub fn dacen(&self) -> DACENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DACENR { bits } + } + #[doc = "Bit 30 - UART7 clock enable"] + #[inline] + pub fn uart7en(&self) -> UART7ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART7ENR { bits } + } + #[doc = "Bit 31 - UART8 clock enable"] + #[inline] + pub fn uart8en(&self) -> UART8ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART8ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM2 clock enable"] + #[inline] + pub fn tim2en(&mut self) -> _TIM2ENW { + _TIM2ENW { w: self } + } + #[doc = "Bit 1 - TIM3 clock enable"] + #[inline] + pub fn tim3en(&mut self) -> _TIM3ENW { + _TIM3ENW { w: self } + } + #[doc = "Bit 2 - TIM4 clock enable"] + #[inline] + pub fn tim4en(&mut self) -> _TIM4ENW { + _TIM4ENW { w: self } + } + #[doc = "Bit 3 - TIM5 clock enable"] + #[inline] + pub fn tim5en(&mut self) -> _TIM5ENW { + _TIM5ENW { w: self } + } + #[doc = "Bit 4 - TIM6EN"] + #[inline] + pub fn tim6en(&mut self) -> _TIM6ENW { + _TIM6ENW { w: self } + } + #[doc = "Bit 5 - TIM7EN"] + #[inline] + pub fn tim7en(&mut self) -> _TIM7ENW { + _TIM7ENW { w: self } + } + #[doc = "Bit 6 - TIM12EN"] + #[inline] + pub fn tim12en(&mut self) -> _TIM12ENW { + _TIM12ENW { w: self } + } + #[doc = "Bit 7 - TIM13EN"] + #[inline] + pub fn tim13en(&mut self) -> _TIM13ENW { + _TIM13ENW { w: self } + } + #[doc = "Bit 8 - TIM14EN"] + #[inline] + pub fn tim14en(&mut self) -> _TIM14ENW { + _TIM14ENW { w: self } + } + #[doc = "Bit 11 - Window watchdog clock enable"] + #[inline] + pub fn wwdgen(&mut self) -> _WWDGENW { + _WWDGENW { w: self } + } + #[doc = "Bit 14 - SPI2 clock enable"] + #[inline] + pub fn spi2en(&mut self) -> _SPI2ENW { + _SPI2ENW { w: self } + } + #[doc = "Bit 15 - SPI3 clock enable"] + #[inline] + pub fn spi3en(&mut self) -> _SPI3ENW { + _SPI3ENW { w: self } + } + #[doc = "Bit 17 - USART 2 clock enable"] + #[inline] + pub fn usart2en(&mut self) -> _USART2ENW { + _USART2ENW { w: self } + } + #[doc = "Bit 18 - USART3EN"] + #[inline] + pub fn usart3en(&mut self) -> _USART3ENW { + _USART3ENW { w: self } + } + #[doc = "Bit 21 - I2C1 clock enable"] + #[inline] + pub fn i2c1en(&mut self) -> _I2C1ENW { + _I2C1ENW { w: self } + } + #[doc = "Bit 22 - I2C2 clock enable"] + #[inline] + pub fn i2c2en(&mut self) -> _I2C2ENW { + _I2C2ENW { w: self } + } + #[doc = "Bit 23 - I2C3 clock enable"] + #[inline] + pub fn i2c3en(&mut self) -> _I2C3ENW { + _I2C3ENW { w: self } + } + #[doc = "Bit 24 - I2C4EN"] + #[inline] + pub fn i2c4en(&mut self) -> _I2C4ENW { + _I2C4ENW { w: self } + } + #[doc = "Bit 25 - CAN1EN"] + #[inline] + pub fn can1en(&mut self) -> _CAN1ENW { + _CAN1ENW { w: self } + } + #[doc = "Bit 26 - CAN2EN"] + #[inline] + pub fn can2en(&mut self) -> _CAN2ENW { + _CAN2ENW { w: self } + } + #[doc = "Bit 28 - Power interface clock enable"] + #[inline] + pub fn pwren(&mut self) -> _PWRENW { + _PWRENW { w: self } + } + #[doc = "Bit 9 - LPTimer 1 clock enable"] + #[inline] + pub fn lptimer1en(&mut self) -> _LPTIMER1ENW { + _LPTIMER1ENW { w: self } + } + #[doc = "Bit 10 - clock enable"] + #[inline] + pub fn rtcapb(&mut self) -> _RTCAPBW { + _RTCAPBW { w: self } + } + #[doc = "Bit 19 - UART 4 clock enable"] + #[inline] + pub fn uart4en(&mut self) -> _UART4ENW { + _UART4ENW { w: self } + } + #[doc = "Bit 20 - UART 5 clock enable"] + #[inline] + pub fn uart5en(&mut self) -> _UART5ENW { + _UART5ENW { w: self } + } + #[doc = "Bit 27 - CAN 3 clock enable"] + #[inline] + pub fn can3en(&mut self) -> _CAN3ENW { + _CAN3ENW { w: self } + } + #[doc = "Bit 29 - DAC clock enable"] + #[inline] + pub fn dacen(&mut self) -> _DACENW { + _DACENW { w: self } + } + #[doc = "Bit 30 - UART7 clock enable"] + #[inline] + pub fn uart7en(&mut self) -> _UART7ENW { + _UART7ENW { w: self } + } + #[doc = "Bit 31 - UART8 clock enable"] + #[inline] + pub fn uart8en(&mut self) -> _UART8ENW { + _UART8ENW { w: self } + } +} diff --git a/src/rcc/apb1lpenr/mod.rs b/src/rcc/apb1lpenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5796b2d533682945b6515751070e11097f8d8d31 --- /dev/null +++ b/src/rcc/apb1lpenr/mod.rs @@ -0,0 +1,1775 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB1LPENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM2LPENR { + bits: bool, +} +impl TIM2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM3LPENR { + bits: bool, +} +impl TIM3LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM4LPENR { + bits: bool, +} +impl TIM4LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM5LPENR { + bits: bool, +} +impl TIM5LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM6LPENR { + bits: bool, +} +impl TIM6LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM7LPENR { + bits: bool, +} +impl TIM7LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM12LPENR { + bits: bool, +} +impl TIM12LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM13LPENR { + bits: bool, +} +impl TIM13LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM14LPENR { + bits: bool, +} +impl TIM14LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WWDGLPENR { + bits: bool, +} +impl WWDGLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI2LPENR { + bits: bool, +} +impl SPI2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI3LPENR { + bits: bool, +} +impl SPI3LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART2LPENR { + bits: bool, +} +impl USART2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART3LPENR { + bits: bool, +} +impl USART3LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C1LPENR { + bits: bool, +} +impl I2C1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C2LPENR { + bits: bool, +} +impl I2C2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C3LPENR { + bits: bool, +} +impl I2C3LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C4LPENR { + bits: bool, +} +impl I2C4LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN1LPENR { + bits: bool, +} +impl CAN1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN2LPENR { + bits: bool, +} +impl CAN2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWRLPENR { + bits: bool, +} +impl PWRLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LPTIMER1LPENR { + bits: bool, +} +impl LPTIMER1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTCAPBENR { + bits: bool, +} +impl RTCAPBENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART4LPENR { + bits: bool, +} +impl USART4LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART5LPENR { + bits: bool, +} +impl USART5LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN3LPENR { + bits: bool, +} +impl CAN3LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DACLPENR { + bits: bool, +} +impl DACLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART7LPENR { + bits: bool, +} +impl UART7LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART8LPENR { + bits: bool, +} +impl UART8LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM3LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM3LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM4LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM4LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM5LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM5LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM6LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM6LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM7LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM7LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM12LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM12LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM13LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM13LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM14LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM14LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WWDGLPENW<'a> { + w: &'a mut W, +} +impl<'a> _WWDGLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI3LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI3LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART3LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART3LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C3LPENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C3LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C4LPENW<'a> { + w: &'a mut W, +} +impl<'a> _I2C4LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWRLPENW<'a> { + w: &'a mut W, +} +impl<'a> _PWRLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LPTIMER1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _LPTIMER1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCAPBENW<'a> { + w: &'a mut W, +} +impl<'a> _RTCAPBENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART4LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART4LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART5LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART5LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN3LPENW<'a> { + w: &'a mut W, +} +impl<'a> _CAN3LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACLPENW<'a> { + w: &'a mut W, +} +impl<'a> _DACLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART7LPENW<'a> { + w: &'a mut W, +} +impl<'a> _UART7LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART8LPENW<'a> { + w: &'a mut W, +} +impl<'a> _UART8LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM2 clock enable during Sleep mode"] + #[inline] + pub fn tim2lpen(&self) -> TIM2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM2LPENR { bits } + } + #[doc = "Bit 1 - TIM3 clock enable during Sleep mode"] + #[inline] + pub fn tim3lpen(&self) -> TIM3LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM3LPENR { bits } + } + #[doc = "Bit 2 - TIM4 clock enable during Sleep mode"] + #[inline] + pub fn tim4lpen(&self) -> TIM4LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM4LPENR { bits } + } + #[doc = "Bit 3 - TIM5 clock enable during Sleep mode"] + #[inline] + pub fn tim5lpen(&self) -> TIM5LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM5LPENR { bits } + } + #[doc = "Bit 4 - TIM6LPEN"] + #[inline] + pub fn tim6lpen(&self) -> TIM6LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM6LPENR { bits } + } + #[doc = "Bit 5 - TIM7LPEN"] + #[inline] + pub fn tim7lpen(&self) -> TIM7LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM7LPENR { bits } + } + #[doc = "Bit 6 - TIM12LPEN"] + #[inline] + pub fn tim12lpen(&self) -> TIM12LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM12LPENR { bits } + } + #[doc = "Bit 7 - TIM13LPEN"] + #[inline] + pub fn tim13lpen(&self) -> TIM13LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM13LPENR { bits } + } + #[doc = "Bit 8 - TIM14LPEN"] + #[inline] + pub fn tim14lpen(&self) -> TIM14LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM14LPENR { bits } + } + #[doc = "Bit 11 - Window watchdog clock enable during Sleep mode"] + #[inline] + pub fn wwdglpen(&self) -> WWDGLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WWDGLPENR { bits } + } + #[doc = "Bit 14 - SPI2 clock enable during Sleep mode"] + #[inline] + pub fn spi2lpen(&self) -> SPI2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI2LPENR { bits } + } + #[doc = "Bit 15 - SPI3 clock enable during Sleep mode"] + #[inline] + pub fn spi3lpen(&self) -> SPI3LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI3LPENR { bits } + } + #[doc = "Bit 17 - USART2 clock enable during Sleep mode"] + #[inline] + pub fn usart2lpen(&self) -> USART2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART2LPENR { bits } + } + #[doc = "Bit 18 - USART3LPEN"] + #[inline] + pub fn usart3lpen(&self) -> USART3LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART3LPENR { bits } + } + #[doc = "Bit 21 - I2C1 clock enable during Sleep mode"] + #[inline] + pub fn i2c1lpen(&self) -> I2C1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C1LPENR { bits } + } + #[doc = "Bit 22 - I2C2 clock enable during Sleep mode"] + #[inline] + pub fn i2c2lpen(&self) -> I2C2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C2LPENR { bits } + } + #[doc = "Bit 23 - I2C3 clock enable during Sleep mode"] + #[inline] + pub fn i2c3lpen(&self) -> I2C3LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C3LPENR { bits } + } + #[doc = "Bit 24 - I2C4LPEN"] + #[inline] + pub fn i2c4lpen(&self) -> I2C4LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C4LPENR { bits } + } + #[doc = "Bit 25 - CAN1LPEN"] + #[inline] + pub fn can1lpen(&self) -> CAN1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN1LPENR { bits } + } + #[doc = "Bit 26 - CAN2LPEN"] + #[inline] + pub fn can2lpen(&self) -> CAN2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN2LPENR { bits } + } + #[doc = "Bit 28 - Power interface clock enable during Sleep mode"] + #[inline] + pub fn pwrlpen(&self) -> PWRLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWRLPENR { bits } + } + #[doc = "Bit 9 - TIM14 clock enable during Sleep mode"] + #[inline] + pub fn lptimer1lpen(&self) -> LPTIMER1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LPTIMER1LPENR { bits } + } + #[doc = "Bit 10 - RTC APB clock enable during Sleep mode"] + #[inline] + pub fn rtcapben(&self) -> RTCAPBENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTCAPBENR { bits } + } + #[doc = "Bit 19 - USART4 clock enable during Sleep mode"] + #[inline] + pub fn usart4lpen(&self) -> USART4LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART4LPENR { bits } + } + #[doc = "Bit 20 - USART5 clock enable during Sleep mode"] + #[inline] + pub fn usart5lpen(&self) -> USART5LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART5LPENR { bits } + } + #[doc = "Bit 27 - CAN3 clock enable during Sleep mode"] + #[inline] + pub fn can3lpen(&self) -> CAN3LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN3LPENR { bits } + } + #[doc = "Bit 29 - DAC clock enable during Sleep mode"] + #[inline] + pub fn daclpen(&self) -> DACLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DACLPENR { bits } + } + #[doc = "Bit 30 - UART7 clock enable during Sleep mode"] + #[inline] + pub fn uart7lpen(&self) -> UART7LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART7LPENR { bits } + } + #[doc = "Bit 31 - UART8 clock enable during Sleep mode"] + #[inline] + pub fn uart8lpen(&self) -> UART8LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART8LPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 922667519 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM2 clock enable during Sleep mode"] + #[inline] + pub fn tim2lpen(&mut self) -> _TIM2LPENW { + _TIM2LPENW { w: self } + } + #[doc = "Bit 1 - TIM3 clock enable during Sleep mode"] + #[inline] + pub fn tim3lpen(&mut self) -> _TIM3LPENW { + _TIM3LPENW { w: self } + } + #[doc = "Bit 2 - TIM4 clock enable during Sleep mode"] + #[inline] + pub fn tim4lpen(&mut self) -> _TIM4LPENW { + _TIM4LPENW { w: self } + } + #[doc = "Bit 3 - TIM5 clock enable during Sleep mode"] + #[inline] + pub fn tim5lpen(&mut self) -> _TIM5LPENW { + _TIM5LPENW { w: self } + } + #[doc = "Bit 4 - TIM6LPEN"] + #[inline] + pub fn tim6lpen(&mut self) -> _TIM6LPENW { + _TIM6LPENW { w: self } + } + #[doc = "Bit 5 - TIM7LPEN"] + #[inline] + pub fn tim7lpen(&mut self) -> _TIM7LPENW { + _TIM7LPENW { w: self } + } + #[doc = "Bit 6 - TIM12LPEN"] + #[inline] + pub fn tim12lpen(&mut self) -> _TIM12LPENW { + _TIM12LPENW { w: self } + } + #[doc = "Bit 7 - TIM13LPEN"] + #[inline] + pub fn tim13lpen(&mut self) -> _TIM13LPENW { + _TIM13LPENW { w: self } + } + #[doc = "Bit 8 - TIM14LPEN"] + #[inline] + pub fn tim14lpen(&mut self) -> _TIM14LPENW { + _TIM14LPENW { w: self } + } + #[doc = "Bit 11 - Window watchdog clock enable during Sleep mode"] + #[inline] + pub fn wwdglpen(&mut self) -> _WWDGLPENW { + _WWDGLPENW { w: self } + } + #[doc = "Bit 14 - SPI2 clock enable during Sleep mode"] + #[inline] + pub fn spi2lpen(&mut self) -> _SPI2LPENW { + _SPI2LPENW { w: self } + } + #[doc = "Bit 15 - SPI3 clock enable during Sleep mode"] + #[inline] + pub fn spi3lpen(&mut self) -> _SPI3LPENW { + _SPI3LPENW { w: self } + } + #[doc = "Bit 17 - USART2 clock enable during Sleep mode"] + #[inline] + pub fn usart2lpen(&mut self) -> _USART2LPENW { + _USART2LPENW { w: self } + } + #[doc = "Bit 18 - USART3LPEN"] + #[inline] + pub fn usart3lpen(&mut self) -> _USART3LPENW { + _USART3LPENW { w: self } + } + #[doc = "Bit 21 - I2C1 clock enable during Sleep mode"] + #[inline] + pub fn i2c1lpen(&mut self) -> _I2C1LPENW { + _I2C1LPENW { w: self } + } + #[doc = "Bit 22 - I2C2 clock enable during Sleep mode"] + #[inline] + pub fn i2c2lpen(&mut self) -> _I2C2LPENW { + _I2C2LPENW { w: self } + } + #[doc = "Bit 23 - I2C3 clock enable during Sleep mode"] + #[inline] + pub fn i2c3lpen(&mut self) -> _I2C3LPENW { + _I2C3LPENW { w: self } + } + #[doc = "Bit 24 - I2C4LPEN"] + #[inline] + pub fn i2c4lpen(&mut self) -> _I2C4LPENW { + _I2C4LPENW { w: self } + } + #[doc = "Bit 25 - CAN1LPEN"] + #[inline] + pub fn can1lpen(&mut self) -> _CAN1LPENW { + _CAN1LPENW { w: self } + } + #[doc = "Bit 26 - CAN2LPEN"] + #[inline] + pub fn can2lpen(&mut self) -> _CAN2LPENW { + _CAN2LPENW { w: self } + } + #[doc = "Bit 28 - Power interface clock enable during Sleep mode"] + #[inline] + pub fn pwrlpen(&mut self) -> _PWRLPENW { + _PWRLPENW { w: self } + } + #[doc = "Bit 9 - TIM14 clock enable during Sleep mode"] + #[inline] + pub fn lptimer1lpen(&mut self) -> _LPTIMER1LPENW { + _LPTIMER1LPENW { w: self } + } + #[doc = "Bit 10 - RTC APB clock enable during Sleep mode"] + #[inline] + pub fn rtcapben(&mut self) -> _RTCAPBENW { + _RTCAPBENW { w: self } + } + #[doc = "Bit 19 - USART4 clock enable during Sleep mode"] + #[inline] + pub fn usart4lpen(&mut self) -> _USART4LPENW { + _USART4LPENW { w: self } + } + #[doc = "Bit 20 - USART5 clock enable during Sleep mode"] + #[inline] + pub fn usart5lpen(&mut self) -> _USART5LPENW { + _USART5LPENW { w: self } + } + #[doc = "Bit 27 - CAN3 clock enable during Sleep mode"] + #[inline] + pub fn can3lpen(&mut self) -> _CAN3LPENW { + _CAN3LPENW { w: self } + } + #[doc = "Bit 29 - DAC clock enable during Sleep mode"] + #[inline] + pub fn daclpen(&mut self) -> _DACLPENW { + _DACLPENW { w: self } + } + #[doc = "Bit 30 - UART7 clock enable during Sleep mode"] + #[inline] + pub fn uart7lpen(&mut self) -> _UART7LPENW { + _UART7LPENW { w: self } + } + #[doc = "Bit 31 - UART8 clock enable during Sleep mode"] + #[inline] + pub fn uart8lpen(&mut self) -> _UART8LPENW { + _UART8LPENW { w: self } + } +} diff --git a/src/rcc/apb1rstr/mod.rs b/src/rcc/apb1rstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b7a2e00917f05b8b5f7504542119efcf92baf63c --- /dev/null +++ b/src/rcc/apb1rstr/mod.rs @@ -0,0 +1,1716 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB1RSTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM2RSTR { + bits: bool, +} +impl TIM2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM3RSTR { + bits: bool, +} +impl TIM3RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM4RSTR { + bits: bool, +} +impl TIM4RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM5RSTR { + bits: bool, +} +impl TIM5RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM6RSTR { + bits: bool, +} +impl TIM6RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM7RSTR { + bits: bool, +} +impl TIM7RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM12RSTR { + bits: bool, +} +impl TIM12RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM13RSTR { + bits: bool, +} +impl TIM13RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM14RSTR { + bits: bool, +} +impl TIM14RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WWDGRSTR { + bits: bool, +} +impl WWDGRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI2RSTR { + bits: bool, +} +impl SPI2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI3RSTR { + bits: bool, +} +impl SPI3RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART2RSTR { + bits: bool, +} +impl UART2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART3RSTR { + bits: bool, +} +impl USART3RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C1RSTR { + bits: bool, +} +impl I2C1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C2RSTR { + bits: bool, +} +impl I2C2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C3RSTR { + bits: bool, +} +impl I2C3RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C4RSTR { + bits: bool, +} +impl I2C4RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN1RSTR { + bits: bool, +} +impl CAN1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN2RSTR { + bits: bool, +} +impl CAN2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWRRSTR { + bits: bool, +} +impl PWRRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LPTIMER1RSTR { + bits: bool, +} +impl LPTIMER1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART4RSTR { + bits: bool, +} +impl USART4RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART5RSTR { + bits: bool, +} +impl USART5RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAN3RSTR { + bits: bool, +} +impl CAN3RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DACRSTR { + bits: bool, +} +impl DACRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART7RSTR { + bits: bool, +} +impl UART7RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UART8RSTR { + bits: bool, +} +impl UART8RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM3RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM3RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM4RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM4RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM5RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM5RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM6RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM6RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM7RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM7RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM12RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM12RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM13RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM13RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM14RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM14RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WWDGRSTW<'a> { + w: &'a mut W, +} +impl<'a> _WWDGRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SPI2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI3RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SPI3RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _UART2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART3RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART3RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _I2C1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _I2C2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C3RSTW<'a> { + w: &'a mut W, +} +impl<'a> _I2C3RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C4RSTW<'a> { + w: &'a mut W, +} +impl<'a> _I2C4RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _CAN1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _CAN2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWRRSTW<'a> { + w: &'a mut W, +} +impl<'a> _PWRRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LPTIMER1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _LPTIMER1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART4RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART4RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART5RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART5RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAN3RSTW<'a> { + w: &'a mut W, +} +impl<'a> _CAN3RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DACRSTW<'a> { + w: &'a mut W, +} +impl<'a> _DACRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART7RSTW<'a> { + w: &'a mut W, +} +impl<'a> _UART7RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UART8RSTW<'a> { + w: &'a mut W, +} +impl<'a> _UART8RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM2 reset"] + #[inline] + pub fn tim2rst(&self) -> TIM2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM2RSTR { bits } + } + #[doc = "Bit 1 - TIM3 reset"] + #[inline] + pub fn tim3rst(&self) -> TIM3RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM3RSTR { bits } + } + #[doc = "Bit 2 - TIM4 reset"] + #[inline] + pub fn tim4rst(&self) -> TIM4RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM4RSTR { bits } + } + #[doc = "Bit 3 - TIM5 reset"] + #[inline] + pub fn tim5rst(&self) -> TIM5RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM5RSTR { bits } + } + #[doc = "Bit 4 - TIM6RST"] + #[inline] + pub fn tim6rst(&self) -> TIM6RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM6RSTR { bits } + } + #[doc = "Bit 5 - TIM7RST"] + #[inline] + pub fn tim7rst(&self) -> TIM7RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM7RSTR { bits } + } + #[doc = "Bit 6 - TIM12RST"] + #[inline] + pub fn tim12rst(&self) -> TIM12RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM12RSTR { bits } + } + #[doc = "Bit 7 - TIM13RST"] + #[inline] + pub fn tim13rst(&self) -> TIM13RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM13RSTR { bits } + } + #[doc = "Bit 8 - TIM14RST"] + #[inline] + pub fn tim14rst(&self) -> TIM14RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM14RSTR { bits } + } + #[doc = "Bit 11 - Window watchdog reset"] + #[inline] + pub fn wwdgrst(&self) -> WWDGRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WWDGRSTR { bits } + } + #[doc = "Bit 14 - SPI 2 reset"] + #[inline] + pub fn spi2rst(&self) -> SPI2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI2RSTR { bits } + } + #[doc = "Bit 15 - SPI 3 reset"] + #[inline] + pub fn spi3rst(&self) -> SPI3RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI3RSTR { bits } + } + #[doc = "Bit 17 - USART 2 reset"] + #[inline] + pub fn uart2rst(&self) -> UART2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART2RSTR { bits } + } + #[doc = "Bit 18 - USART3RST"] + #[inline] + pub fn usart3rst(&self) -> USART3RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART3RSTR { bits } + } + #[doc = "Bit 21 - I2C 1 reset"] + #[inline] + pub fn i2c1rst(&self) -> I2C1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C1RSTR { bits } + } + #[doc = "Bit 22 - I2C 2 reset"] + #[inline] + pub fn i2c2rst(&self) -> I2C2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C2RSTR { bits } + } + #[doc = "Bit 23 - I2C3 reset"] + #[inline] + pub fn i2c3rst(&self) -> I2C3RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C3RSTR { bits } + } + #[doc = "Bit 24 - I2C4RST"] + #[inline] + pub fn i2c4rst(&self) -> I2C4RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C4RSTR { bits } + } + #[doc = "Bit 25 - CAN1RST"] + #[inline] + pub fn can1rst(&self) -> CAN1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN1RSTR { bits } + } + #[doc = "Bit 26 - CAN2RST"] + #[inline] + pub fn can2rst(&self) -> CAN2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN2RSTR { bits } + } + #[doc = "Bit 28 - Power interface reset"] + #[inline] + pub fn pwrrst(&self) -> PWRRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWRRSTR { bits } + } + #[doc = "Bit 9 - LPTimer1 reset"] + #[inline] + pub fn lptimer1rst(&self) -> LPTIMER1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LPTIMER1RSTR { bits } + } + #[doc = "Bit 19 - USART4 reset"] + #[inline] + pub fn usart4rst(&self) -> USART4RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART4RSTR { bits } + } + #[doc = "Bit 20 - USART5 reset"] + #[inline] + pub fn usart5rst(&self) -> USART5RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART5RSTR { bits } + } + #[doc = "Bit 27 - CAN 3 reset"] + #[inline] + pub fn can3rst(&self) -> CAN3RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAN3RSTR { bits } + } + #[doc = "Bit 29 - DAC reset"] + #[inline] + pub fn dacrst(&self) -> DACRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DACRSTR { bits } + } + #[doc = "Bit 30 - UART 7 reset"] + #[inline] + pub fn uart7rst(&self) -> UART7RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART7RSTR { bits } + } + #[doc = "Bit 31 - UART 8 reset"] + #[inline] + pub fn uart8rst(&self) -> UART8RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UART8RSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM2 reset"] + #[inline] + pub fn tim2rst(&mut self) -> _TIM2RSTW { + _TIM2RSTW { w: self } + } + #[doc = "Bit 1 - TIM3 reset"] + #[inline] + pub fn tim3rst(&mut self) -> _TIM3RSTW { + _TIM3RSTW { w: self } + } + #[doc = "Bit 2 - TIM4 reset"] + #[inline] + pub fn tim4rst(&mut self) -> _TIM4RSTW { + _TIM4RSTW { w: self } + } + #[doc = "Bit 3 - TIM5 reset"] + #[inline] + pub fn tim5rst(&mut self) -> _TIM5RSTW { + _TIM5RSTW { w: self } + } + #[doc = "Bit 4 - TIM6RST"] + #[inline] + pub fn tim6rst(&mut self) -> _TIM6RSTW { + _TIM6RSTW { w: self } + } + #[doc = "Bit 5 - TIM7RST"] + #[inline] + pub fn tim7rst(&mut self) -> _TIM7RSTW { + _TIM7RSTW { w: self } + } + #[doc = "Bit 6 - TIM12RST"] + #[inline] + pub fn tim12rst(&mut self) -> _TIM12RSTW { + _TIM12RSTW { w: self } + } + #[doc = "Bit 7 - TIM13RST"] + #[inline] + pub fn tim13rst(&mut self) -> _TIM13RSTW { + _TIM13RSTW { w: self } + } + #[doc = "Bit 8 - TIM14RST"] + #[inline] + pub fn tim14rst(&mut self) -> _TIM14RSTW { + _TIM14RSTW { w: self } + } + #[doc = "Bit 11 - Window watchdog reset"] + #[inline] + pub fn wwdgrst(&mut self) -> _WWDGRSTW { + _WWDGRSTW { w: self } + } + #[doc = "Bit 14 - SPI 2 reset"] + #[inline] + pub fn spi2rst(&mut self) -> _SPI2RSTW { + _SPI2RSTW { w: self } + } + #[doc = "Bit 15 - SPI 3 reset"] + #[inline] + pub fn spi3rst(&mut self) -> _SPI3RSTW { + _SPI3RSTW { w: self } + } + #[doc = "Bit 17 - USART 2 reset"] + #[inline] + pub fn uart2rst(&mut self) -> _UART2RSTW { + _UART2RSTW { w: self } + } + #[doc = "Bit 18 - USART3RST"] + #[inline] + pub fn usart3rst(&mut self) -> _USART3RSTW { + _USART3RSTW { w: self } + } + #[doc = "Bit 21 - I2C 1 reset"] + #[inline] + pub fn i2c1rst(&mut self) -> _I2C1RSTW { + _I2C1RSTW { w: self } + } + #[doc = "Bit 22 - I2C 2 reset"] + #[inline] + pub fn i2c2rst(&mut self) -> _I2C2RSTW { + _I2C2RSTW { w: self } + } + #[doc = "Bit 23 - I2C3 reset"] + #[inline] + pub fn i2c3rst(&mut self) -> _I2C3RSTW { + _I2C3RSTW { w: self } + } + #[doc = "Bit 24 - I2C4RST"] + #[inline] + pub fn i2c4rst(&mut self) -> _I2C4RSTW { + _I2C4RSTW { w: self } + } + #[doc = "Bit 25 - CAN1RST"] + #[inline] + pub fn can1rst(&mut self) -> _CAN1RSTW { + _CAN1RSTW { w: self } + } + #[doc = "Bit 26 - CAN2RST"] + #[inline] + pub fn can2rst(&mut self) -> _CAN2RSTW { + _CAN2RSTW { w: self } + } + #[doc = "Bit 28 - Power interface reset"] + #[inline] + pub fn pwrrst(&mut self) -> _PWRRSTW { + _PWRRSTW { w: self } + } + #[doc = "Bit 9 - LPTimer1 reset"] + #[inline] + pub fn lptimer1rst(&mut self) -> _LPTIMER1RSTW { + _LPTIMER1RSTW { w: self } + } + #[doc = "Bit 19 - USART4 reset"] + #[inline] + pub fn usart4rst(&mut self) -> _USART4RSTW { + _USART4RSTW { w: self } + } + #[doc = "Bit 20 - USART5 reset"] + #[inline] + pub fn usart5rst(&mut self) -> _USART5RSTW { + _USART5RSTW { w: self } + } + #[doc = "Bit 27 - CAN 3 reset"] + #[inline] + pub fn can3rst(&mut self) -> _CAN3RSTW { + _CAN3RSTW { w: self } + } + #[doc = "Bit 29 - DAC reset"] + #[inline] + pub fn dacrst(&mut self) -> _DACRSTW { + _DACRSTW { w: self } + } + #[doc = "Bit 30 - UART 7 reset"] + #[inline] + pub fn uart7rst(&mut self) -> _UART7RSTW { + _UART7RSTW { w: self } + } + #[doc = "Bit 31 - UART 8 reset"] + #[inline] + pub fn uart8rst(&mut self) -> _UART8RSTW { + _UART8RSTW { w: self } + } +} diff --git a/src/rcc/apb2enr/mod.rs b/src/rcc/apb2enr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b30e6bac58f90ac8cfdc975565aaa3a4a600ac90 --- /dev/null +++ b/src/rcc/apb2enr/mod.rs @@ -0,0 +1,1008 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB2ENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM1ENR { + bits: bool, +} +impl TIM1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM8ENR { + bits: bool, +} +impl TIM8ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART1ENR { + bits: bool, +} +impl USART1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART6ENR { + bits: bool, +} +impl USART6ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADC1ENR { + bits: bool, +} +impl ADC1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOENR { + bits: bool, +} +impl SDIOENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI1ENR { + bits: bool, +} +impl SPI1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI4ENR { + bits: bool, +} +impl SPI4ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SYSCFGENR { + bits: bool, +} +impl SYSCFGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM9ENR { + bits: bool, +} +impl TIM9ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM10ENR { + bits: bool, +} +impl TIM10ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM11ENR { + bits: bool, +} +impl TIM11ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDMENR { + bits: bool, +} +impl DFSDMENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI5ENR { + bits: bool, +} +impl SPI5ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAI1ENR { + bits: bool, +} +impl SAI1ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDM2ENR { + bits: bool, +} +impl DFSDM2ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM1ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM8ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM8ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART1ENW<'a> { + w: &'a mut W, +} +impl<'a> _USART1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART6ENW<'a> { + w: &'a mut W, +} +impl<'a> _USART6ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADC1ENW<'a> { + w: &'a mut W, +} +impl<'a> _ADC1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIOENW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI1ENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI4ENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI4ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SYSCFGENW<'a> { + w: &'a mut W, +} +impl<'a> _SYSCFGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM9ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM9ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM10ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM10ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM11ENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM11ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDMENW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDMENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI5ENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI5ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SAI1ENW<'a> { + w: &'a mut W, +} +impl<'a> _SAI1ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDM2ENW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDM2ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM1 clock enable"] + #[inline] + pub fn tim1en(&self) -> TIM1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM1ENR { bits } + } + #[doc = "Bit 1 - TIM8EN"] + #[inline] + pub fn tim8en(&self) -> TIM8ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM8ENR { bits } + } + #[doc = "Bit 4 - USART1 clock enable"] + #[inline] + pub fn usart1en(&self) -> USART1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART1ENR { bits } + } + #[doc = "Bit 5 - USART6 clock enable"] + #[inline] + pub fn usart6en(&self) -> USART6ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART6ENR { bits } + } + #[doc = "Bit 8 - ADC1 clock enable"] + #[inline] + pub fn adc1en(&self) -> ADC1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADC1ENR { bits } + } + #[doc = "Bit 11 - SDIO clock enable"] + #[inline] + pub fn sdioen(&self) -> SDIOENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOENR { bits } + } + #[doc = "Bit 12 - SPI1 clock enable"] + #[inline] + pub fn spi1en(&self) -> SPI1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI1ENR { bits } + } + #[doc = "Bit 13 - SPI4 clock enable"] + #[inline] + pub fn spi4en(&self) -> SPI4ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI4ENR { bits } + } + #[doc = "Bit 14 - System configuration controller clock enable"] + #[inline] + pub fn syscfgen(&self) -> SYSCFGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SYSCFGENR { bits } + } + #[doc = "Bit 16 - TIM9 clock enable"] + #[inline] + pub fn tim9en(&self) -> TIM9ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM9ENR { bits } + } + #[doc = "Bit 17 - TIM10 clock enable"] + #[inline] + pub fn tim10en(&self) -> TIM10ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM10ENR { bits } + } + #[doc = "Bit 18 - TIM11 clock enable"] + #[inline] + pub fn tim11en(&self) -> TIM11ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM11ENR { bits } + } + #[doc = "Bit 24 - DFSDMEN"] + #[inline] + pub fn dfsdmen(&self) -> DFSDMENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDMENR { bits } + } + #[doc = "Bit 20 - SPI5 clock enable"] + #[inline] + pub fn spi5en(&self) -> SPI5ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI5ENR { bits } + } + #[doc = "Bit 22 - SAI 1 clock enable"] + #[inline] + pub fn sai1en(&self) -> SAI1ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAI1ENR { bits } + } + #[doc = "Bit 25 - DFSDM2 clock enable"] + #[inline] + pub fn dfsdm2en(&self) -> DFSDM2ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDM2ENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM1 clock enable"] + #[inline] + pub fn tim1en(&mut self) -> _TIM1ENW { + _TIM1ENW { w: self } + } + #[doc = "Bit 1 - TIM8EN"] + #[inline] + pub fn tim8en(&mut self) -> _TIM8ENW { + _TIM8ENW { w: self } + } + #[doc = "Bit 4 - USART1 clock enable"] + #[inline] + pub fn usart1en(&mut self) -> _USART1ENW { + _USART1ENW { w: self } + } + #[doc = "Bit 5 - USART6 clock enable"] + #[inline] + pub fn usart6en(&mut self) -> _USART6ENW { + _USART6ENW { w: self } + } + #[doc = "Bit 8 - ADC1 clock enable"] + #[inline] + pub fn adc1en(&mut self) -> _ADC1ENW { + _ADC1ENW { w: self } + } + #[doc = "Bit 11 - SDIO clock enable"] + #[inline] + pub fn sdioen(&mut self) -> _SDIOENW { + _SDIOENW { w: self } + } + #[doc = "Bit 12 - SPI1 clock enable"] + #[inline] + pub fn spi1en(&mut self) -> _SPI1ENW { + _SPI1ENW { w: self } + } + #[doc = "Bit 13 - SPI4 clock enable"] + #[inline] + pub fn spi4en(&mut self) -> _SPI4ENW { + _SPI4ENW { w: self } + } + #[doc = "Bit 14 - System configuration controller clock enable"] + #[inline] + pub fn syscfgen(&mut self) -> _SYSCFGENW { + _SYSCFGENW { w: self } + } + #[doc = "Bit 16 - TIM9 clock enable"] + #[inline] + pub fn tim9en(&mut self) -> _TIM9ENW { + _TIM9ENW { w: self } + } + #[doc = "Bit 17 - TIM10 clock enable"] + #[inline] + pub fn tim10en(&mut self) -> _TIM10ENW { + _TIM10ENW { w: self } + } + #[doc = "Bit 18 - TIM11 clock enable"] + #[inline] + pub fn tim11en(&mut self) -> _TIM11ENW { + _TIM11ENW { w: self } + } + #[doc = "Bit 24 - DFSDMEN"] + #[inline] + pub fn dfsdmen(&mut self) -> _DFSDMENW { + _DFSDMENW { w: self } + } + #[doc = "Bit 20 - SPI5 clock enable"] + #[inline] + pub fn spi5en(&mut self) -> _SPI5ENW { + _SPI5ENW { w: self } + } + #[doc = "Bit 22 - SAI 1 clock enable"] + #[inline] + pub fn sai1en(&mut self) -> _SAI1ENW { + _SAI1ENW { w: self } + } + #[doc = "Bit 25 - DFSDM2 clock enable"] + #[inline] + pub fn dfsdm2en(&mut self) -> _DFSDM2ENW { + _DFSDM2ENW { w: self } + } +} diff --git a/src/rcc/apb2lpenr/mod.rs b/src/rcc/apb2lpenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2526e670de97affb67a5942597f466ec3ca43b23 --- /dev/null +++ b/src/rcc/apb2lpenr/mod.rs @@ -0,0 +1,1185 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB2LPENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM1LPENR { + bits: bool, +} +impl TIM1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM8LPENR { + bits: bool, +} +impl TIM8LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART1LPENR { + bits: bool, +} +impl USART1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART6LPENR { + bits: bool, +} +impl USART6LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADC1LPENR { + bits: bool, +} +impl ADC1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOLPENR { + bits: bool, +} +impl SDIOLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI1LPENR { + bits: bool, +} +impl SPI1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI4LPENR { + bits: bool, +} +impl SPI4LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SYSCFGLPENR { + bits: bool, +} +impl SYSCFGLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM9LPENR { + bits: bool, +} +impl TIM9LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM10LPENR { + bits: bool, +} +impl TIM10LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM11LPENR { + bits: bool, +} +impl TIM11LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDMLPENR { + bits: bool, +} +impl DFSDMLPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART9LPENR { + bits: bool, +} +impl USART9LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART10LPENR { + bits: bool, +} +impl USART10LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EXTITENR { + bits: bool, +} +impl EXTITENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI5LPENR { + bits: bool, +} +impl SPI5LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAI1LPENR { + bits: bool, +} +impl SAI1LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDM2LPENR { + bits: bool, +} +impl DFSDM2LPENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM8LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM8LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART6LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART6LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADC1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _ADC1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIOLPENW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI4LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI4LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SYSCFGLPENW<'a> { + w: &'a mut W, +} +impl<'a> _SYSCFGLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM9LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM9LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM10LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM10LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM11LPENW<'a> { + w: &'a mut W, +} +impl<'a> _TIM11LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDMLPENW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDMLPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART9LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART9LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART10LPENW<'a> { + w: &'a mut W, +} +impl<'a> _USART10LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTITENW<'a> { + w: &'a mut W, +} +impl<'a> _EXTITENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI5LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SPI5LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SAI1LPENW<'a> { + w: &'a mut W, +} +impl<'a> _SAI1LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDM2LPENW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDM2LPENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM1 clock enable during Sleep mode"] + #[inline] + pub fn tim1lpen(&self) -> TIM1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM1LPENR { bits } + } + #[doc = "Bit 1 - TIM8LPEN"] + #[inline] + pub fn tim8lpen(&self) -> TIM8LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM8LPENR { bits } + } + #[doc = "Bit 4 - USART1 clock enable during Sleep mode"] + #[inline] + pub fn usart1lpen(&self) -> USART1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART1LPENR { bits } + } + #[doc = "Bit 5 - USART6 clock enable during Sleep mode"] + #[inline] + pub fn usart6lpen(&self) -> USART6LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART6LPENR { bits } + } + #[doc = "Bit 8 - ADC1 clock enable during Sleep mode"] + #[inline] + pub fn adc1lpen(&self) -> ADC1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADC1LPENR { bits } + } + #[doc = "Bit 11 - SDIO clock enable during Sleep mode"] + #[inline] + pub fn sdiolpen(&self) -> SDIOLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOLPENR { bits } + } + #[doc = "Bit 12 - SPI 1 clock enable during Sleep mode"] + #[inline] + pub fn spi1lpen(&self) -> SPI1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI1LPENR { bits } + } + #[doc = "Bit 13 - SPI4 clock enable during Sleep mode"] + #[inline] + pub fn spi4lpen(&self) -> SPI4LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI4LPENR { bits } + } + #[doc = "Bit 14 - System configuration controller clock enable during Sleep mode"] + #[inline] + pub fn syscfglpen(&self) -> SYSCFGLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SYSCFGLPENR { bits } + } + #[doc = "Bit 16 - TIM9 clock enable during sleep mode"] + #[inline] + pub fn tim9lpen(&self) -> TIM9LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM9LPENR { bits } + } + #[doc = "Bit 17 - TIM10 clock enable during Sleep mode"] + #[inline] + pub fn tim10lpen(&self) -> TIM10LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM10LPENR { bits } + } + #[doc = "Bit 18 - TIM11 clock enable during Sleep mode"] + #[inline] + pub fn tim11lpen(&self) -> TIM11LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM11LPENR { bits } + } + #[doc = "Bit 24 - DFSDMLPEN"] + #[inline] + pub fn dfsdmlpen(&self) -> DFSDMLPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDMLPENR { bits } + } + #[doc = "Bit 6 - USART9 clock enable during Sleep mode"] + #[inline] + pub fn usart9lpen(&self) -> USART9LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART9LPENR { bits } + } + #[doc = "Bit 7 - USART10 clock enable during Sleep mode"] + #[inline] + pub fn usart10lpen(&self) -> USART10LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART10LPENR { bits } + } + #[doc = "Bit 15 - EXTIT APB and SYSCTRL PFREE clock enable during Sleep mode"] + #[inline] + pub fn extiten(&self) -> EXTITENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EXTITENR { bits } + } + #[doc = "Bit 20 - SPI5 clock enable during Sleep mode"] + #[inline] + pub fn spi5lpen(&self) -> SPI5LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI5LPENR { bits } + } + #[doc = "Bit 22 - SAI1 clock enable during Sleep mode"] + #[inline] + pub fn sai1lpen(&self) -> SAI1LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAI1LPENR { bits } + } + #[doc = "Bit 25 - DFSDM2 clock enable during Sleep mode"] + #[inline] + pub fn dfsdm2lpen(&self) -> DFSDM2LPENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDM2LPENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 483123 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM1 clock enable during Sleep mode"] + #[inline] + pub fn tim1lpen(&mut self) -> _TIM1LPENW { + _TIM1LPENW { w: self } + } + #[doc = "Bit 1 - TIM8LPEN"] + #[inline] + pub fn tim8lpen(&mut self) -> _TIM8LPENW { + _TIM8LPENW { w: self } + } + #[doc = "Bit 4 - USART1 clock enable during Sleep mode"] + #[inline] + pub fn usart1lpen(&mut self) -> _USART1LPENW { + _USART1LPENW { w: self } + } + #[doc = "Bit 5 - USART6 clock enable during Sleep mode"] + #[inline] + pub fn usart6lpen(&mut self) -> _USART6LPENW { + _USART6LPENW { w: self } + } + #[doc = "Bit 8 - ADC1 clock enable during Sleep mode"] + #[inline] + pub fn adc1lpen(&mut self) -> _ADC1LPENW { + _ADC1LPENW { w: self } + } + #[doc = "Bit 11 - SDIO clock enable during Sleep mode"] + #[inline] + pub fn sdiolpen(&mut self) -> _SDIOLPENW { + _SDIOLPENW { w: self } + } + #[doc = "Bit 12 - SPI 1 clock enable during Sleep mode"] + #[inline] + pub fn spi1lpen(&mut self) -> _SPI1LPENW { + _SPI1LPENW { w: self } + } + #[doc = "Bit 13 - SPI4 clock enable during Sleep mode"] + #[inline] + pub fn spi4lpen(&mut self) -> _SPI4LPENW { + _SPI4LPENW { w: self } + } + #[doc = "Bit 14 - System configuration controller clock enable during Sleep mode"] + #[inline] + pub fn syscfglpen(&mut self) -> _SYSCFGLPENW { + _SYSCFGLPENW { w: self } + } + #[doc = "Bit 16 - TIM9 clock enable during sleep mode"] + #[inline] + pub fn tim9lpen(&mut self) -> _TIM9LPENW { + _TIM9LPENW { w: self } + } + #[doc = "Bit 17 - TIM10 clock enable during Sleep mode"] + #[inline] + pub fn tim10lpen(&mut self) -> _TIM10LPENW { + _TIM10LPENW { w: self } + } + #[doc = "Bit 18 - TIM11 clock enable during Sleep mode"] + #[inline] + pub fn tim11lpen(&mut self) -> _TIM11LPENW { + _TIM11LPENW { w: self } + } + #[doc = "Bit 24 - DFSDMLPEN"] + #[inline] + pub fn dfsdmlpen(&mut self) -> _DFSDMLPENW { + _DFSDMLPENW { w: self } + } + #[doc = "Bit 6 - USART9 clock enable during Sleep mode"] + #[inline] + pub fn usart9lpen(&mut self) -> _USART9LPENW { + _USART9LPENW { w: self } + } + #[doc = "Bit 7 - USART10 clock enable during Sleep mode"] + #[inline] + pub fn usart10lpen(&mut self) -> _USART10LPENW { + _USART10LPENW { w: self } + } + #[doc = "Bit 15 - EXTIT APB and SYSCTRL PFREE clock enable during Sleep mode"] + #[inline] + pub fn extiten(&mut self) -> _EXTITENW { + _EXTITENW { w: self } + } + #[doc = "Bit 20 - SPI5 clock enable during Sleep mode"] + #[inline] + pub fn spi5lpen(&mut self) -> _SPI5LPENW { + _SPI5LPENW { w: self } + } + #[doc = "Bit 22 - SAI1 clock enable during Sleep mode"] + #[inline] + pub fn sai1lpen(&mut self) -> _SAI1LPENW { + _SAI1LPENW { w: self } + } + #[doc = "Bit 25 - DFSDM2 clock enable during Sleep mode"] + #[inline] + pub fn dfsdm2lpen(&mut self) -> _DFSDM2LPENW { + _DFSDM2LPENW { w: self } + } +} diff --git a/src/rcc/apb2rstr/mod.rs b/src/rcc/apb2rstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6145e4b432046a7964d92d6a5f087ec2dee102ca --- /dev/null +++ b/src/rcc/apb2rstr/mod.rs @@ -0,0 +1,1126 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::APB2RSTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIM1RSTR { + bits: bool, +} +impl TIM1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM8RSTR { + bits: bool, +} +impl TIM8RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART1RSTR { + bits: bool, +} +impl USART1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART6RSTR { + bits: bool, +} +impl USART6RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADCRSTR { + bits: bool, +} +impl ADCRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIORSTR { + bits: bool, +} +impl SDIORSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI1RSTR { + bits: bool, +} +impl SPI1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SYSCFGRSTR { + bits: bool, +} +impl SYSCFGRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM9RSTR { + bits: bool, +} +impl TIM9RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM10RSTR { + bits: bool, +} +impl TIM10RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIM11RSTR { + bits: bool, +} +impl TIM11RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDMRSTR { + bits: bool, +} +impl DFSDMRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct USART9RSTR { + bits: bool, +} +impl USART9RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SART10RSTR { + bits: bool, +} +impl SART10RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI4RSTR { + bits: bool, +} +impl SPI4RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPI5RSTR { + bits: bool, +} +impl SPI5RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAI1RSTR { + bits: bool, +} +impl SAI1RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DFSDM2RSTR { + bits: bool, +} +impl DFSDM2RSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIM1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM8RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM8RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART6RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART6RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADCRSTW<'a> { + w: &'a mut W, +} +impl<'a> _ADCRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIORSTW<'a> { + w: &'a mut W, +} +impl<'a> _SDIORSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SPI1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SYSCFGRSTW<'a> { + w: &'a mut W, +} +impl<'a> _SYSCFGRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM9RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM9RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM10RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM10RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIM11RSTW<'a> { + w: &'a mut W, +} +impl<'a> _TIM11RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDMRSTW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDMRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _USART9RSTW<'a> { + w: &'a mut W, +} +impl<'a> _USART9RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SART10RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SART10RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI4RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SPI4RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPI5RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SPI5RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SAI1RSTW<'a> { + w: &'a mut W, +} +impl<'a> _SAI1RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DFSDM2RSTW<'a> { + w: &'a mut W, +} +impl<'a> _DFSDM2RSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - TIM1 reset"] + #[inline] + pub fn tim1rst(&self) -> TIM1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM1RSTR { bits } + } + #[doc = "Bit 1 - TIM8RST"] + #[inline] + pub fn tim8rst(&self) -> TIM8RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM8RSTR { bits } + } + #[doc = "Bit 4 - USART1 reset"] + #[inline] + pub fn usart1rst(&self) -> USART1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART1RSTR { bits } + } + #[doc = "Bit 5 - USART6 reset"] + #[inline] + pub fn usart6rst(&self) -> USART6RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART6RSTR { bits } + } + #[doc = "Bit 8 - ADC interface reset (common to all ADCs)"] + #[inline] + pub fn adcrst(&self) -> ADCRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADCRSTR { bits } + } + #[doc = "Bit 11 - SDIO reset"] + #[inline] + pub fn sdiorst(&self) -> SDIORSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIORSTR { bits } + } + #[doc = "Bit 12 - SPI 1 reset"] + #[inline] + pub fn spi1rst(&self) -> SPI1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI1RSTR { bits } + } + #[doc = "Bit 14 - System configuration controller reset"] + #[inline] + pub fn syscfgrst(&self) -> SYSCFGRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SYSCFGRSTR { bits } + } + #[doc = "Bit 16 - TIM9 reset"] + #[inline] + pub fn tim9rst(&self) -> TIM9RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM9RSTR { bits } + } + #[doc = "Bit 17 - TIM10 reset"] + #[inline] + pub fn tim10rst(&self) -> TIM10RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM10RSTR { bits } + } + #[doc = "Bit 18 - TIM11 reset"] + #[inline] + pub fn tim11rst(&self) -> TIM11RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIM11RSTR { bits } + } + #[doc = "Bit 24 - DFSDMRST"] + #[inline] + pub fn dfsdmrst(&self) -> DFSDMRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDMRSTR { bits } + } + #[doc = "Bit 6 - USART9 reset"] + #[inline] + pub fn usart9rst(&self) -> USART9RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + USART9RSTR { bits } + } + #[doc = "Bit 7 - USART10 reset"] + #[inline] + pub fn sart10rst(&self) -> SART10RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SART10RSTR { bits } + } + #[doc = "Bit 13 - SPI4 reset"] + #[inline] + pub fn spi4rst(&self) -> SPI4RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI4RSTR { bits } + } + #[doc = "Bit 20 - SPI5RST"] + #[inline] + pub fn spi5rst(&self) -> SPI5RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPI5RSTR { bits } + } + #[doc = "Bit 22 - SAI1 reset"] + #[inline] + pub fn sai1rst(&self) -> SAI1RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAI1RSTR { bits } + } + #[doc = "Bit 25 - DFSDM2 reset"] + #[inline] + pub fn dfsdm2rst(&self) -> DFSDM2RSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DFSDM2RSTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - TIM1 reset"] + #[inline] + pub fn tim1rst(&mut self) -> _TIM1RSTW { + _TIM1RSTW { w: self } + } + #[doc = "Bit 1 - TIM8RST"] + #[inline] + pub fn tim8rst(&mut self) -> _TIM8RSTW { + _TIM8RSTW { w: self } + } + #[doc = "Bit 4 - USART1 reset"] + #[inline] + pub fn usart1rst(&mut self) -> _USART1RSTW { + _USART1RSTW { w: self } + } + #[doc = "Bit 5 - USART6 reset"] + #[inline] + pub fn usart6rst(&mut self) -> _USART6RSTW { + _USART6RSTW { w: self } + } + #[doc = "Bit 8 - ADC interface reset (common to all ADCs)"] + #[inline] + pub fn adcrst(&mut self) -> _ADCRSTW { + _ADCRSTW { w: self } + } + #[doc = "Bit 11 - SDIO reset"] + #[inline] + pub fn sdiorst(&mut self) -> _SDIORSTW { + _SDIORSTW { w: self } + } + #[doc = "Bit 12 - SPI 1 reset"] + #[inline] + pub fn spi1rst(&mut self) -> _SPI1RSTW { + _SPI1RSTW { w: self } + } + #[doc = "Bit 14 - System configuration controller reset"] + #[inline] + pub fn syscfgrst(&mut self) -> _SYSCFGRSTW { + _SYSCFGRSTW { w: self } + } + #[doc = "Bit 16 - TIM9 reset"] + #[inline] + pub fn tim9rst(&mut self) -> _TIM9RSTW { + _TIM9RSTW { w: self } + } + #[doc = "Bit 17 - TIM10 reset"] + #[inline] + pub fn tim10rst(&mut self) -> _TIM10RSTW { + _TIM10RSTW { w: self } + } + #[doc = "Bit 18 - TIM11 reset"] + #[inline] + pub fn tim11rst(&mut self) -> _TIM11RSTW { + _TIM11RSTW { w: self } + } + #[doc = "Bit 24 - DFSDMRST"] + #[inline] + pub fn dfsdmrst(&mut self) -> _DFSDMRSTW { + _DFSDMRSTW { w: self } + } + #[doc = "Bit 6 - USART9 reset"] + #[inline] + pub fn usart9rst(&mut self) -> _USART9RSTW { + _USART9RSTW { w: self } + } + #[doc = "Bit 7 - USART10 reset"] + #[inline] + pub fn sart10rst(&mut self) -> _SART10RSTW { + _SART10RSTW { w: self } + } + #[doc = "Bit 13 - SPI4 reset"] + #[inline] + pub fn spi4rst(&mut self) -> _SPI4RSTW { + _SPI4RSTW { w: self } + } + #[doc = "Bit 20 - SPI5RST"] + #[inline] + pub fn spi5rst(&mut self) -> _SPI5RSTW { + _SPI5RSTW { w: self } + } + #[doc = "Bit 22 - SAI1 reset"] + #[inline] + pub fn sai1rst(&mut self) -> _SAI1RSTW { + _SAI1RSTW { w: self } + } + #[doc = "Bit 25 - DFSDM2 reset"] + #[inline] + pub fn dfsdm2rst(&mut self) -> _DFSDM2RSTW { + _DFSDM2RSTW { w: self } + } +} diff --git a/src/rcc/bdcr/mod.rs b/src/rcc/bdcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c7d93e1e342dc0213180960b5c1b3c2b48223f18 --- /dev/null +++ b/src/rcc/bdcr/mod.rs @@ -0,0 +1,508 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BDCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BDRSTR { + bits: bool, +} +impl BDRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTCENR { + bits: bool, +} +impl RTCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTCSEL1R { + bits: bool, +} +impl RTCSEL1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTCSEL0R { + bits: bool, +} +impl RTCSEL0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSEBYPR { + bits: bool, +} +impl LSEBYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSERDYR { + bits: bool, +} +impl LSERDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSEONR { + bits: bool, +} +impl LSEONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSEMODR { + bits: bool, +} +impl LSEMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _BDRSTW<'a> { + w: &'a mut W, +} +impl<'a> _BDRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCENW<'a> { + w: &'a mut W, +} +impl<'a> _RTCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCSEL1W<'a> { + w: &'a mut W, +} +impl<'a> _RTCSEL1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCSEL0W<'a> { + w: &'a mut W, +} +impl<'a> _RTCSEL0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSEBYPW<'a> { + w: &'a mut W, +} +impl<'a> _LSEBYPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSEONW<'a> { + w: &'a mut W, +} +impl<'a> _LSEONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSEMODW<'a> { + w: &'a mut W, +} +impl<'a> _LSEMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - Backup domain software reset"] + #[inline] + pub fn bdrst(&self) -> BDRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BDRSTR { bits } + } + #[doc = "Bit 15 - RTC clock enable"] + #[inline] + pub fn rtcen(&self) -> RTCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTCENR { bits } + } + #[doc = "Bit 9 - RTC clock source selection"] + #[inline] + pub fn rtcsel1(&self) -> RTCSEL1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTCSEL1R { bits } + } + #[doc = "Bit 8 - RTC clock source selection"] + #[inline] + pub fn rtcsel0(&self) -> RTCSEL0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTCSEL0R { bits } + } + #[doc = "Bit 2 - External low-speed oscillator bypass"] + #[inline] + pub fn lsebyp(&self) -> LSEBYPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSEBYPR { bits } + } + #[doc = "Bit 1 - External low-speed oscillator ready"] + #[inline] + pub fn lserdy(&self) -> LSERDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSERDYR { bits } + } + #[doc = "Bit 0 - External low-speed oscillator enable"] + #[inline] + pub fn lseon(&self) -> LSEONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSEONR { bits } + } + #[doc = "Bit 3 - External low-speed oscillator bypass"] + #[inline] + pub fn lsemod(&self) -> LSEMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSEMODR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - Backup domain software reset"] + #[inline] + pub fn bdrst(&mut self) -> _BDRSTW { + _BDRSTW { w: self } + } + #[doc = "Bit 15 - RTC clock enable"] + #[inline] + pub fn rtcen(&mut self) -> _RTCENW { + _RTCENW { w: self } + } + #[doc = "Bit 9 - RTC clock source selection"] + #[inline] + pub fn rtcsel1(&mut self) -> _RTCSEL1W { + _RTCSEL1W { w: self } + } + #[doc = "Bit 8 - RTC clock source selection"] + #[inline] + pub fn rtcsel0(&mut self) -> _RTCSEL0W { + _RTCSEL0W { w: self } + } + #[doc = "Bit 2 - External low-speed oscillator bypass"] + #[inline] + pub fn lsebyp(&mut self) -> _LSEBYPW { + _LSEBYPW { w: self } + } + #[doc = "Bit 0 - External low-speed oscillator enable"] + #[inline] + pub fn lseon(&mut self) -> _LSEONW { + _LSEONW { w: self } + } + #[doc = "Bit 3 - External low-speed oscillator bypass"] + #[inline] + pub fn lsemod(&mut self) -> _LSEMODW { + _LSEMODW { w: self } + } +} diff --git a/src/rcc/cfgr/mod.rs b/src/rcc/cfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5fb906d8a7756381fa1421e5d7cc9fbe76dd6555 --- /dev/null +++ b/src/rcc/cfgr/mod.rs @@ -0,0 +1,572 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCO2R { + bits: u8, +} +impl MCO2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCO2PRER { + bits: u8, +} +impl MCO2PRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCO1PRER { + bits: u8, +} +impl MCO1PRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MCO1R { + bits: u8, +} +impl MCO1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct RTCPRER { + bits: u8, +} +impl RTCPRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PPRE2R { + bits: u8, +} +impl PPRE2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PPRE1R { + bits: u8, +} +impl PPRE1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HPRER { + bits: u8, +} +impl HPRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SWS1R { + bits: bool, +} +impl SWS1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SWS0R { + bits: bool, +} +impl SWS0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SW1R { + bits: bool, +} +impl SW1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SW0R { + bits: bool, +} +impl SW0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _MCO2W<'a> { + w: &'a mut W, +} +impl<'a> _MCO2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCO2PREW<'a> { + w: &'a mut W, +} +impl<'a> _MCO2PREW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCO1PREW<'a> { + w: &'a mut W, +} +impl<'a> _MCO1PREW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MCO1W<'a> { + w: &'a mut W, +} +impl<'a> _MCO1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTCPREW<'a> { + w: &'a mut W, +} +impl<'a> _RTCPREW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PPRE2W<'a> { + w: &'a mut W, +} +impl<'a> _PPRE2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PPRE1W<'a> { + w: &'a mut W, +} +impl<'a> _PPRE1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HPREW<'a> { + w: &'a mut W, +} +impl<'a> _HPREW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SW1W<'a> { + w: &'a mut W, +} +impl<'a> _SW1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SW0W<'a> { + w: &'a mut W, +} +impl<'a> _SW0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 30:31 - Microcontroller clock output 2"] + #[inline] + pub fn mco2(&self) -> MCO2R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCO2R { bits } + } + #[doc = "Bits 27:29 - MCO2 prescaler"] + #[inline] + pub fn mco2pre(&self) -> MCO2PRER { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCO2PRER { bits } + } + #[doc = "Bits 24:26 - MCO1 prescaler"] + #[inline] + pub fn mco1pre(&self) -> MCO1PRER { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCO1PRER { bits } + } + #[doc = "Bits 21:22 - Microcontroller clock output 1"] + #[inline] + pub fn mco1(&self) -> MCO1R { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCO1R { bits } + } + #[doc = "Bits 16:20 - HSE division factor for RTC clock"] + #[inline] + pub fn rtcpre(&self) -> RTCPRER { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RTCPRER { bits } + } + #[doc = "Bits 13:15 - APB high-speed prescaler (APB2)"] + #[inline] + pub fn ppre2(&self) -> PPRE2R { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PPRE2R { bits } + } + #[doc = "Bits 10:12 - APB Low speed prescaler (APB1)"] + #[inline] + pub fn ppre1(&self) -> PPRE1R { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PPRE1R { bits } + } + #[doc = "Bits 4:7 - AHB prescaler"] + #[inline] + pub fn hpre(&self) -> HPRER { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HPRER { bits } + } + #[doc = "Bit 3 - System clock switch status"] + #[inline] + pub fn sws1(&self) -> SWS1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWS1R { bits } + } + #[doc = "Bit 2 - System clock switch status"] + #[inline] + pub fn sws0(&self) -> SWS0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SWS0R { bits } + } + #[doc = "Bit 1 - System clock switch"] + #[inline] + pub fn sw1(&self) -> SW1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SW1R { bits } + } + #[doc = "Bit 0 - System clock switch"] + #[inline] + pub fn sw0(&self) -> SW0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SW0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 30:31 - Microcontroller clock output 2"] + #[inline] + pub fn mco2(&mut self) -> _MCO2W { + _MCO2W { w: self } + } + #[doc = "Bits 27:29 - MCO2 prescaler"] + #[inline] + pub fn mco2pre(&mut self) -> _MCO2PREW { + _MCO2PREW { w: self } + } + #[doc = "Bits 24:26 - MCO1 prescaler"] + #[inline] + pub fn mco1pre(&mut self) -> _MCO1PREW { + _MCO1PREW { w: self } + } + #[doc = "Bits 21:22 - Microcontroller clock output 1"] + #[inline] + pub fn mco1(&mut self) -> _MCO1W { + _MCO1W { w: self } + } + #[doc = "Bits 16:20 - HSE division factor for RTC clock"] + #[inline] + pub fn rtcpre(&mut self) -> _RTCPREW { + _RTCPREW { w: self } + } + #[doc = "Bits 13:15 - APB high-speed prescaler (APB2)"] + #[inline] + pub fn ppre2(&mut self) -> _PPRE2W { + _PPRE2W { w: self } + } + #[doc = "Bits 10:12 - APB Low speed prescaler (APB1)"] + #[inline] + pub fn ppre1(&mut self) -> _PPRE1W { + _PPRE1W { w: self } + } + #[doc = "Bits 4:7 - AHB prescaler"] + #[inline] + pub fn hpre(&mut self) -> _HPREW { + _HPREW { w: self } + } + #[doc = "Bit 1 - System clock switch"] + #[inline] + pub fn sw1(&mut self) -> _SW1W { + _SW1W { w: self } + } + #[doc = "Bit 0 - System clock switch"] + #[inline] + pub fn sw0(&mut self) -> _SW0W { + _SW0W { w: self } + } +} diff --git a/src/rcc/cir/mod.rs b/src/rcc/cir/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..03222f5566eedadc08d737113f03c614e81da4e2 --- /dev/null +++ b/src/rcc/cir/mod.rs @@ -0,0 +1,831 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CIR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SRDYIER { + bits: bool, +} +impl PLLI2SRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLRDYIER { + bits: bool, +} +impl PLLRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSERDYIER { + bits: bool, +} +impl HSERDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSIRDYIER { + bits: bool, +} +impl HSIRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSERDYIER { + bits: bool, +} +impl LSERDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSIRDYIER { + bits: bool, +} +impl LSIRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CSSFR { + bits: bool, +} +impl CSSFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SRDYFR { + bits: bool, +} +impl PLLI2SRDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLRDYFR { + bits: bool, +} +impl PLLRDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSERDYFR { + bits: bool, +} +impl HSERDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSIRDYFR { + bits: bool, +} +impl HSIRDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSERDYFR { + bits: bool, +} +impl LSERDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSIRDYFR { + bits: bool, +} +impl LSIRDYFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CSSCW<'a> { + w: &'a mut W, +} +impl<'a> _CSSCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SRDYCW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SRDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLRDYCW<'a> { + w: &'a mut W, +} +impl<'a> _PLLRDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSERDYCW<'a> { + w: &'a mut W, +} +impl<'a> _HSERDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSIRDYCW<'a> { + w: &'a mut W, +} +impl<'a> _HSIRDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSERDYCW<'a> { + w: &'a mut W, +} +impl<'a> _LSERDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSIRDYCW<'a> { + w: &'a mut W, +} +impl<'a> _LSIRDYCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _PLLRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSERDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _HSERDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSIRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _HSIRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSERDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _LSERDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSIRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _LSIRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 13 - PLLI2S ready interrupt enable"] + #[inline] + pub fn plli2srdyie(&self) -> PLLI2SRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLI2SRDYIER { bits } + } + #[doc = "Bit 12 - Main PLL (PLL) ready interrupt enable"] + #[inline] + pub fn pllrdyie(&self) -> PLLRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLRDYIER { bits } + } + #[doc = "Bit 11 - HSE ready interrupt enable"] + #[inline] + pub fn hserdyie(&self) -> HSERDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSERDYIER { bits } + } + #[doc = "Bit 10 - HSI ready interrupt enable"] + #[inline] + pub fn hsirdyie(&self) -> HSIRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSIRDYIER { bits } + } + #[doc = "Bit 9 - LSE ready interrupt enable"] + #[inline] + pub fn lserdyie(&self) -> LSERDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSERDYIER { bits } + } + #[doc = "Bit 8 - LSI ready interrupt enable"] + #[inline] + pub fn lsirdyie(&self) -> LSIRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSIRDYIER { bits } + } + #[doc = "Bit 7 - Clock security system interrupt flag"] + #[inline] + pub fn cssf(&self) -> CSSFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CSSFR { bits } + } + #[doc = "Bit 5 - PLLI2S ready interrupt flag"] + #[inline] + pub fn plli2srdyf(&self) -> PLLI2SRDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLI2SRDYFR { bits } + } + #[doc = "Bit 4 - Main PLL (PLL) ready interrupt flag"] + #[inline] + pub fn pllrdyf(&self) -> PLLRDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLRDYFR { bits } + } + #[doc = "Bit 3 - HSE ready interrupt flag"] + #[inline] + pub fn hserdyf(&self) -> HSERDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSERDYFR { bits } + } + #[doc = "Bit 2 - HSI ready interrupt flag"] + #[inline] + pub fn hsirdyf(&self) -> HSIRDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSIRDYFR { bits } + } + #[doc = "Bit 1 - LSE ready interrupt flag"] + #[inline] + pub fn lserdyf(&self) -> LSERDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSERDYFR { bits } + } + #[doc = "Bit 0 - LSI ready interrupt flag"] + #[inline] + pub fn lsirdyf(&self) -> LSIRDYFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSIRDYFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 23 - Clock security system interrupt clear"] + #[inline] + pub fn cssc(&mut self) -> _CSSCW { + _CSSCW { w: self } + } + #[doc = "Bit 21 - PLLI2S ready interrupt clear"] + #[inline] + pub fn plli2srdyc(&mut self) -> _PLLI2SRDYCW { + _PLLI2SRDYCW { w: self } + } + #[doc = "Bit 20 - Main PLL(PLL) ready interrupt clear"] + #[inline] + pub fn pllrdyc(&mut self) -> _PLLRDYCW { + _PLLRDYCW { w: self } + } + #[doc = "Bit 19 - HSE ready interrupt clear"] + #[inline] + pub fn hserdyc(&mut self) -> _HSERDYCW { + _HSERDYCW { w: self } + } + #[doc = "Bit 18 - HSI ready interrupt clear"] + #[inline] + pub fn hsirdyc(&mut self) -> _HSIRDYCW { + _HSIRDYCW { w: self } + } + #[doc = "Bit 17 - LSE ready interrupt clear"] + #[inline] + pub fn lserdyc(&mut self) -> _LSERDYCW { + _LSERDYCW { w: self } + } + #[doc = "Bit 16 - LSI ready interrupt clear"] + #[inline] + pub fn lsirdyc(&mut self) -> _LSIRDYCW { + _LSIRDYCW { w: self } + } + #[doc = "Bit 13 - PLLI2S ready interrupt enable"] + #[inline] + pub fn plli2srdyie(&mut self) -> _PLLI2SRDYIEW { + _PLLI2SRDYIEW { w: self } + } + #[doc = "Bit 12 - Main PLL (PLL) ready interrupt enable"] + #[inline] + pub fn pllrdyie(&mut self) -> _PLLRDYIEW { + _PLLRDYIEW { w: self } + } + #[doc = "Bit 11 - HSE ready interrupt enable"] + #[inline] + pub fn hserdyie(&mut self) -> _HSERDYIEW { + _HSERDYIEW { w: self } + } + #[doc = "Bit 10 - HSI ready interrupt enable"] + #[inline] + pub fn hsirdyie(&mut self) -> _HSIRDYIEW { + _HSIRDYIEW { w: self } + } + #[doc = "Bit 9 - LSE ready interrupt enable"] + #[inline] + pub fn lserdyie(&mut self) -> _LSERDYIEW { + _LSERDYIEW { w: self } + } + #[doc = "Bit 8 - LSI ready interrupt enable"] + #[inline] + pub fn lsirdyie(&mut self) -> _LSIRDYIEW { + _LSIRDYIEW { w: self } + } +} diff --git a/src/rcc/ckgatenr/mod.rs b/src/rcc/ckgatenr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8d16830cdc6f03a8892526e527c9e934cbb22f4c --- /dev/null +++ b/src/rcc/ckgatenr/mod.rs @@ -0,0 +1,536 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CKGATENR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct AHB2APB1_CKENR { + bits: bool, +} +impl AHB2APB1_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AHB2APB2_CKENR { + bits: bool, +} +impl AHB2APB2_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CM4DBG_CKENR { + bits: bool, +} +impl CM4DBG_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPARE_CKENR { + bits: bool, +} +impl SPARE_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SRAM_CKENR { + bits: bool, +} +impl SRAM_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FLITF_CKENR { + bits: bool, +} +impl FLITF_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RCC_CKENR { + bits: bool, +} +impl RCC_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EVTCL_CKENR { + bits: bool, +} +impl EVTCL_CKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _AHB2APB1_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _AHB2APB1_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AHB2APB2_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _AHB2APB2_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CM4DBG_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _CM4DBG_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPARE_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _SPARE_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SRAM_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _SRAM_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FLITF_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _FLITF_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RCC_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _RCC_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EVTCL_CKENW<'a> { + w: &'a mut W, +} +impl<'a> _EVTCL_CKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - AHB to APB1 Bridge clock enable"] + #[inline] + pub fn ahb2apb1_cken(&self) -> AHB2APB1_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AHB2APB1_CKENR { bits } + } + #[doc = "Bit 1 - AHB to APB2 Bridge clock enable"] + #[inline] + pub fn ahb2apb2_cken(&self) -> AHB2APB2_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AHB2APB2_CKENR { bits } + } + #[doc = "Bit 2 - Cortex M4 ETM clock enable"] + #[inline] + pub fn cm4dbg_cken(&self) -> CM4DBG_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CM4DBG_CKENR { bits } + } + #[doc = "Bit 3 - Spare clock enable"] + #[inline] + pub fn spare_cken(&self) -> SPARE_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPARE_CKENR { bits } + } + #[doc = "Bit 4 - SRQAM controller clock enable"] + #[inline] + pub fn sram_cken(&self) -> SRAM_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SRAM_CKENR { bits } + } + #[doc = "Bit 5 - Flash Interface clock enable"] + #[inline] + pub fn flitf_cken(&self) -> FLITF_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FLITF_CKENR { bits } + } + #[doc = "Bit 6 - RCC clock enable"] + #[inline] + pub fn rcc_cken(&self) -> RCC_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RCC_CKENR { bits } + } + #[doc = "Bit 7 - EVTCL_CKEN"] + #[inline] + pub fn evtcl_cken(&self) -> EVTCL_CKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EVTCL_CKENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - AHB to APB1 Bridge clock enable"] + #[inline] + pub fn ahb2apb1_cken(&mut self) -> _AHB2APB1_CKENW { + _AHB2APB1_CKENW { w: self } + } + #[doc = "Bit 1 - AHB to APB2 Bridge clock enable"] + #[inline] + pub fn ahb2apb2_cken(&mut self) -> _AHB2APB2_CKENW { + _AHB2APB2_CKENW { w: self } + } + #[doc = "Bit 2 - Cortex M4 ETM clock enable"] + #[inline] + pub fn cm4dbg_cken(&mut self) -> _CM4DBG_CKENW { + _CM4DBG_CKENW { w: self } + } + #[doc = "Bit 3 - Spare clock enable"] + #[inline] + pub fn spare_cken(&mut self) -> _SPARE_CKENW { + _SPARE_CKENW { w: self } + } + #[doc = "Bit 4 - SRQAM controller clock enable"] + #[inline] + pub fn sram_cken(&mut self) -> _SRAM_CKENW { + _SRAM_CKENW { w: self } + } + #[doc = "Bit 5 - Flash Interface clock enable"] + #[inline] + pub fn flitf_cken(&mut self) -> _FLITF_CKENW { + _FLITF_CKENW { w: self } + } + #[doc = "Bit 6 - RCC clock enable"] + #[inline] + pub fn rcc_cken(&mut self) -> _RCC_CKENW { + _RCC_CKENW { w: self } + } + #[doc = "Bit 7 - EVTCL_CKEN"] + #[inline] + pub fn evtcl_cken(&mut self) -> _EVTCL_CKENW { + _EVTCL_CKENW { w: self } + } +} diff --git a/src/rcc/cr/mod.rs b/src/rcc/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cd54d85035fd7ac4feebfa51fbd7552c2b5aa5a3 --- /dev/null +++ b/src/rcc/cr/mod.rs @@ -0,0 +1,736 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct HSIONR { + bits: bool, +} +impl HSIONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSIRDYR { + bits: bool, +} +impl HSIRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSITRIMR { + bits: u8, +} +impl HSITRIMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HSICALR { + bits: u8, +} +impl HSICALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HSEONR { + bits: bool, +} +impl HSEONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSERDYR { + bits: bool, +} +impl HSERDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HSEBYPR { + bits: bool, +} +impl HSEBYPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CSSONR { + bits: bool, +} +impl CSSONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLONR { + bits: bool, +} +impl PLLONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLRDYR { + bits: bool, +} +impl PLLRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SONR { + bits: bool, +} +impl PLLI2SONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SRDYR { + bits: bool, +} +impl PLLI2SRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _HSIONW<'a> { + w: &'a mut W, +} +impl<'a> _HSIONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSIRDYW<'a> { + w: &'a mut W, +} +impl<'a> _HSIRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSITRIMW<'a> { + w: &'a mut W, +} +impl<'a> _HSITRIMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSICALW<'a> { + w: &'a mut W, +} +impl<'a> _HSICALW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSEONW<'a> { + w: &'a mut W, +} +impl<'a> _HSEONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSERDYW<'a> { + w: &'a mut W, +} +impl<'a> _HSERDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HSEBYPW<'a> { + w: &'a mut W, +} +impl<'a> _HSEBYPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CSSONW<'a> { + w: &'a mut W, +} +impl<'a> _CSSONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLONW<'a> { + w: &'a mut W, +} +impl<'a> _PLLONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLRDYW<'a> { + w: &'a mut W, +} +impl<'a> _PLLRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SONW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SRDYW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Internal high-speed clock enable"] + #[inline] + pub fn hsion(&self) -> HSIONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSIONR { bits } + } + #[doc = "Bit 1 - Internal high-speed clock ready flag"] + #[inline] + pub fn hsirdy(&self) -> HSIRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSIRDYR { bits } + } + #[doc = "Bits 3:7 - Internal high-speed clock trimming"] + #[inline] + pub fn hsitrim(&self) -> HSITRIMR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HSITRIMR { bits } + } + #[doc = "Bits 8:15 - Internal high-speed clock calibration"] + #[inline] + pub fn hsical(&self) -> HSICALR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HSICALR { bits } + } + #[doc = "Bit 16 - HSE clock enable"] + #[inline] + pub fn hseon(&self) -> HSEONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSEONR { bits } + } + #[doc = "Bit 17 - HSE clock ready flag"] + #[inline] + pub fn hserdy(&self) -> HSERDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSERDYR { bits } + } + #[doc = "Bit 18 - HSE clock bypass"] + #[inline] + pub fn hsebyp(&self) -> HSEBYPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HSEBYPR { bits } + } + #[doc = "Bit 19 - Clock security system enable"] + #[inline] + pub fn csson(&self) -> CSSONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CSSONR { bits } + } + #[doc = "Bit 24 - Main PLL (PLL) enable"] + #[inline] + pub fn pllon(&self) -> PLLONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLONR { bits } + } + #[doc = "Bit 25 - Main PLL (PLL) clock ready flag"] + #[inline] + pub fn pllrdy(&self) -> PLLRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLRDYR { bits } + } + #[doc = "Bit 26 - PLLI2S enable"] + #[inline] + pub fn plli2son(&self) -> PLLI2SONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLI2SONR { bits } + } + #[doc = "Bit 27 - PLLI2S clock ready flag"] + #[inline] + pub fn plli2srdy(&self) -> PLLI2SRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLI2SRDYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 131 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Internal high-speed clock enable"] + #[inline] + pub fn hsion(&mut self) -> _HSIONW { + _HSIONW { w: self } + } + #[doc = "Bit 1 - Internal high-speed clock ready flag"] + #[inline] + pub fn hsirdy(&mut self) -> _HSIRDYW { + _HSIRDYW { w: self } + } + #[doc = "Bits 3:7 - Internal high-speed clock trimming"] + #[inline] + pub fn hsitrim(&mut self) -> _HSITRIMW { + _HSITRIMW { w: self } + } + #[doc = "Bits 8:15 - Internal high-speed clock calibration"] + #[inline] + pub fn hsical(&mut self) -> _HSICALW { + _HSICALW { w: self } + } + #[doc = "Bit 16 - HSE clock enable"] + #[inline] + pub fn hseon(&mut self) -> _HSEONW { + _HSEONW { w: self } + } + #[doc = "Bit 17 - HSE clock ready flag"] + #[inline] + pub fn hserdy(&mut self) -> _HSERDYW { + _HSERDYW { w: self } + } + #[doc = "Bit 18 - HSE clock bypass"] + #[inline] + pub fn hsebyp(&mut self) -> _HSEBYPW { + _HSEBYPW { w: self } + } + #[doc = "Bit 19 - Clock security system enable"] + #[inline] + pub fn csson(&mut self) -> _CSSONW { + _CSSONW { w: self } + } + #[doc = "Bit 24 - Main PLL (PLL) enable"] + #[inline] + pub fn pllon(&mut self) -> _PLLONW { + _PLLONW { w: self } + } + #[doc = "Bit 25 - Main PLL (PLL) clock ready flag"] + #[inline] + pub fn pllrdy(&mut self) -> _PLLRDYW { + _PLLRDYW { w: self } + } + #[doc = "Bit 26 - PLLI2S enable"] + #[inline] + pub fn plli2son(&mut self) -> _PLLI2SONW { + _PLLI2SONW { w: self } + } + #[doc = "Bit 27 - PLLI2S clock ready flag"] + #[inline] + pub fn plli2srdy(&mut self) -> _PLLI2SRDYW { + _PLLI2SRDYW { w: self } + } +} diff --git a/src/rcc/csr/mod.rs b/src/rcc/csr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..34fad42f7157b520ac21e870f750c416866f1759 --- /dev/null +++ b/src/rcc/csr/mod.rs @@ -0,0 +1,626 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LPWRRSTFR { + bits: bool, +} +impl LPWRRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WWDGRSTFR { + bits: bool, +} +impl WWDGRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WDGRSTFR { + bits: bool, +} +impl WDGRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SFTRSTFR { + bits: bool, +} +impl SFTRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PORRSTFR { + bits: bool, +} +impl PORRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PADRSTFR { + bits: bool, +} +impl PADRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BORRSTFR { + bits: bool, +} +impl BORRSTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RMVFR { + bits: bool, +} +impl RMVFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSIRDYR { + bits: bool, +} +impl LSIRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSIONR { + bits: bool, +} +impl LSIONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LPWRRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _LPWRRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WWDGRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _WWDGRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDGRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _WDGRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 29; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SFTRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _SFTRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PORRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _PORRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PADRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _PADRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BORRSTFW<'a> { + w: &'a mut W, +} +impl<'a> _BORRSTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RMVFW<'a> { + w: &'a mut W, +} +impl<'a> _RMVFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSIONW<'a> { + w: &'a mut W, +} +impl<'a> _LSIONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Low-power reset flag"] + #[inline] + pub fn lpwrrstf(&self) -> LPWRRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LPWRRSTFR { bits } + } + #[doc = "Bit 30 - Window watchdog reset flag"] + #[inline] + pub fn wwdgrstf(&self) -> WWDGRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WWDGRSTFR { bits } + } + #[doc = "Bit 29 - Independent watchdog reset flag"] + #[inline] + pub fn wdgrstf(&self) -> WDGRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 29; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDGRSTFR { bits } + } + #[doc = "Bit 28 - Software reset flag"] + #[inline] + pub fn sftrstf(&self) -> SFTRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SFTRSTFR { bits } + } + #[doc = "Bit 27 - POR/PDR reset flag"] + #[inline] + pub fn porrstf(&self) -> PORRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PORRSTFR { bits } + } + #[doc = "Bit 26 - PIN reset flag"] + #[inline] + pub fn padrstf(&self) -> PADRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PADRSTFR { bits } + } + #[doc = "Bit 25 - BOR reset flag"] + #[inline] + pub fn borrstf(&self) -> BORRSTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BORRSTFR { bits } + } + #[doc = "Bit 24 - Remove reset flag"] + #[inline] + pub fn rmvf(&self) -> RMVFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RMVFR { bits } + } + #[doc = "Bit 1 - Internal low-speed oscillator ready"] + #[inline] + pub fn lsirdy(&self) -> LSIRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSIRDYR { bits } + } + #[doc = "Bit 0 - Internal low-speed oscillator enable"] + #[inline] + pub fn lsion(&self) -> LSIONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSIONR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 234881024 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Low-power reset flag"] + #[inline] + pub fn lpwrrstf(&mut self) -> _LPWRRSTFW { + _LPWRRSTFW { w: self } + } + #[doc = "Bit 30 - Window watchdog reset flag"] + #[inline] + pub fn wwdgrstf(&mut self) -> _WWDGRSTFW { + _WWDGRSTFW { w: self } + } + #[doc = "Bit 29 - Independent watchdog reset flag"] + #[inline] + pub fn wdgrstf(&mut self) -> _WDGRSTFW { + _WDGRSTFW { w: self } + } + #[doc = "Bit 28 - Software reset flag"] + #[inline] + pub fn sftrstf(&mut self) -> _SFTRSTFW { + _SFTRSTFW { w: self } + } + #[doc = "Bit 27 - POR/PDR reset flag"] + #[inline] + pub fn porrstf(&mut self) -> _PORRSTFW { + _PORRSTFW { w: self } + } + #[doc = "Bit 26 - PIN reset flag"] + #[inline] + pub fn padrstf(&mut self) -> _PADRSTFW { + _PADRSTFW { w: self } + } + #[doc = "Bit 25 - BOR reset flag"] + #[inline] + pub fn borrstf(&mut self) -> _BORRSTFW { + _BORRSTFW { w: self } + } + #[doc = "Bit 24 - Remove reset flag"] + #[inline] + pub fn rmvf(&mut self) -> _RMVFW { + _RMVFW { w: self } + } + #[doc = "Bit 0 - Internal low-speed oscillator enable"] + #[inline] + pub fn lsion(&mut self) -> _LSIONW { + _LSIONW { w: self } + } +} diff --git a/src/rcc/dckcfgr/mod.rs b/src/rcc/dckcfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..752d153f2f1fc2b6129c0123426088a4464fed02 --- /dev/null +++ b/src/rcc/dckcfgr/mod.rs @@ -0,0 +1,305 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCKCFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDFSDM1ASELR { + bits: bool, +} +impl CKDFSDM1ASELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIMPRER { + bits: bool, +} +impl TIMPRER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2S1SRCR { + bits: u8, +} +impl I2S1SRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct I2S2SRCR { + bits: u8, +} +impl I2S2SRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct LPTIMER1SELR { + bits: u8, +} +impl LPTIMER1SELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CKDFSDM1ASELW<'a> { + w: &'a mut W, +} +impl<'a> _CKDFSDM1ASELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIMPREW<'a> { + w: &'a mut W, +} +impl<'a> _TIMPREW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2S1SRCW<'a> { + w: &'a mut W, +} +impl<'a> _I2S1SRCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2S2SRCW<'a> { + w: &'a mut W, +} +impl<'a> _I2S2SRCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LPTIMER1SELW<'a> { + w: &'a mut W, +} +impl<'a> _LPTIMER1SELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - DFSDM1 audio clock selection."] + #[inline] + pub fn ckdfsdm1asel(&self) -> CKDFSDM1ASELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKDFSDM1ASELR { bits } + } + #[doc = "Bit 24 - Timers clocks prescalers selection"] + #[inline] + pub fn timpre(&self) -> TIMPRER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIMPRER { bits } + } + #[doc = "Bits 25:26 - I2S APB1 clocks source selection (I2S2/3)"] + #[inline] + pub fn i2s1src(&self) -> I2S1SRCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + I2S1SRCR { bits } + } + #[doc = "Bits 27:28 - I2S APB2 clocks source selection (I2S1/4/5)"] + #[inline] + pub fn i2s2src(&self) -> I2S2SRCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + I2S2SRCR { bits } + } + #[doc = "Bits 30:31 - LPTIMER1 kernel clock selection."] + #[inline] + pub fn lptimer1sel(&self) -> LPTIMER1SELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + LPTIMER1SELR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - DFSDM1 audio clock selection."] + #[inline] + pub fn ckdfsdm1asel(&mut self) -> _CKDFSDM1ASELW { + _CKDFSDM1ASELW { w: self } + } + #[doc = "Bit 24 - Timers clocks prescalers selection"] + #[inline] + pub fn timpre(&mut self) -> _TIMPREW { + _TIMPREW { w: self } + } + #[doc = "Bits 25:26 - I2S APB1 clocks source selection (I2S2/3)"] + #[inline] + pub fn i2s1src(&mut self) -> _I2S1SRCW { + _I2S1SRCW { w: self } + } + #[doc = "Bits 27:28 - I2S APB2 clocks source selection (I2S1/4/5)"] + #[inline] + pub fn i2s2src(&mut self) -> _I2S2SRCW { + _I2S2SRCW { w: self } + } + #[doc = "Bits 30:31 - LPTIMER1 kernel clock selection."] + #[inline] + pub fn lptimer1sel(&mut self) -> _LPTIMER1SELW { + _LPTIMER1SELW { w: self } + } +} diff --git a/src/rcc/dckcfgr2/mod.rs b/src/rcc/dckcfgr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2139161dbecb00764e18b4a90478532b5fb3bc58 --- /dev/null +++ b/src/rcc/dckcfgr2/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCKCFGR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKSDIOSELR { + bits: bool, +} +impl CKSDIOSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CK48MSELR { + bits: bool, +} +impl CK48MSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2CFMP1SELR { + bits: bool, +} +impl I2CFMP1SELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKSDIOSELW<'a> { + w: &'a mut W, +} +impl<'a> _CKSDIOSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CK48MSELW<'a> { + w: &'a mut W, +} +impl<'a> _CK48MSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2CFMP1SELW<'a> { + w: &'a mut W, +} +impl<'a> _I2CFMP1SELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 28 - SDIO clock selection."] + #[inline] + pub fn cksdiosel(&self) -> CKSDIOSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKSDIOSELR { bits } + } + #[doc = "Bit 27 - SDIO/USBFS clock selection."] + #[inline] + pub fn ck48msel(&self) -> CK48MSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CK48MSELR { bits } + } + #[doc = "Bit 22 - I2CFMP1 kernel clock source selection"] + #[inline] + pub fn i2cfmp1sel(&self) -> I2CFMP1SELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2CFMP1SELR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 28 - SDIO clock selection."] + #[inline] + pub fn cksdiosel(&mut self) -> _CKSDIOSELW { + _CKSDIOSELW { w: self } + } + #[doc = "Bit 27 - SDIO/USBFS clock selection."] + #[inline] + pub fn ck48msel(&mut self) -> _CK48MSELW { + _CK48MSELW { w: self } + } + #[doc = "Bit 22 - I2CFMP1 kernel clock source selection"] + #[inline] + pub fn i2cfmp1sel(&mut self) -> _I2CFMP1SELW { + _I2CFMP1SELW { w: self } + } +} diff --git a/src/rcc/mod.rs b/src/rcc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4041e5948b3a1c96a09dd2883c6829b01135c38e --- /dev/null +++ b/src/rcc/mod.rs @@ -0,0 +1,220 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - clock control register"] + pub cr: CR, + #[doc = "0x04 - PLL configuration register"] + pub pllcfgr: PLLCFGR, + #[doc = "0x08 - clock configuration register"] + pub cfgr: CFGR, + #[doc = "0x0c - clock interrupt register"] + pub cir: CIR, + #[doc = "0x10 - AHB1 peripheral reset register"] + pub ahb1rstr: AHB1RSTR, + #[doc = "0x14 - AHB2 peripheral reset register"] + pub ahb2rstr: AHB2RSTR, + #[doc = "0x18 - peripheral reset register"] + pub ahb3rstr: AHB3RSTR, + _reserved0: [u8; 4usize], + #[doc = "0x20 - APB1 peripheral reset register"] + pub apb1rstr: APB1RSTR, + #[doc = "0x24 - APB2 peripheral reset register"] + pub apb2rstr: APB2RSTR, + _reserved1: [u8; 8usize], + #[doc = "0x30 - AHB1 peripheral clock register"] + pub ahb1enr: AHB1ENR, + #[doc = "0x34 - AHB2 peripheral clock enable register"] + pub ahb2enr: AHB2ENR, + #[doc = "0x38 - AHB3 peripheral clock enable register"] + pub ahb3enr: AHB3ENR, + _reserved2: [u8; 4usize], + #[doc = "0x40 - APB1 peripheral clock enable register"] + pub apb1enr: APB1ENR, + #[doc = "0x44 - APB2 peripheral clock enable register"] + pub apb2enr: APB2ENR, + _reserved3: [u8; 8usize], + #[doc = "0x50 - AHB1 peripheral clock enable in low power mode register"] + pub ahb1lpenr: AHB1LPENR, + #[doc = "0x54 - AHB2 peripheral clock enable in low power mode register"] + pub ahb2lpenr: AHB2LPENR, + #[doc = "0x58 - AHB3 peripheral clock enable in low power mode register"] + pub ahb3lpenr: AHB3LPENR, + _reserved4: [u8; 4usize], + #[doc = "0x60 - APB1 peripheral clock enable in low power mode register"] + pub apb1lpenr: APB1LPENR, + #[doc = "0x64 - APB2 peripheral clock enabled in low power mode register"] + pub apb2lpenr: APB2LPENR, + _reserved5: [u8; 8usize], + #[doc = "0x70 - Backup domain control register"] + pub bdcr: BDCR, + #[doc = "0x74 - clock control & status register"] + pub csr: CSR, + _reserved6: [u8; 8usize], + #[doc = "0x80 - spread spectrum clock generation register"] + pub sscgr: SSCGR, + #[doc = "0x84 - PLLI2S configuration register"] + pub plli2scfgr: PLLI2SCFGR, + _reserved7: [u8; 4usize], + #[doc = "0x8c - Dedicated Clocks Configuration Register"] + pub dckcfgr: DCKCFGR, + #[doc = "0x90 - RCC clocks gated enable register"] + pub ckgatenr: CKGATENR, + #[doc = "0x94 - Dedicated Clocks Configuration Register"] + pub dckcfgr2: DCKCFGR2, +} +#[doc = "clock control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "clock control register"] +pub mod cr; +#[doc = "PLL configuration register"] +pub struct PLLCFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PLL configuration register"] +pub mod pllcfgr; +#[doc = "clock configuration register"] +pub struct CFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "clock configuration register"] +pub mod cfgr; +#[doc = "clock interrupt register"] +pub struct CIR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "clock interrupt register"] +pub mod cir; +#[doc = "AHB1 peripheral reset register"] +pub struct AHB1RSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB1 peripheral reset register"] +pub mod ahb1rstr; +#[doc = "AHB2 peripheral reset register"] +pub struct AHB2RSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB2 peripheral reset register"] +pub mod ahb2rstr; +#[doc = "APB1 peripheral reset register"] +pub struct APB1RSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB1 peripheral reset register"] +pub mod apb1rstr; +#[doc = "APB2 peripheral reset register"] +pub struct APB2RSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB2 peripheral reset register"] +pub mod apb2rstr; +#[doc = "AHB1 peripheral clock register"] +pub struct AHB1ENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB1 peripheral clock register"] +pub mod ahb1enr; +#[doc = "AHB2 peripheral clock enable register"] +pub struct AHB2ENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB2 peripheral clock enable register"] +pub mod ahb2enr; +#[doc = "APB1 peripheral clock enable register"] +pub struct APB1ENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB1 peripheral clock enable register"] +pub mod apb1enr; +#[doc = "APB2 peripheral clock enable register"] +pub struct APB2ENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB2 peripheral clock enable register"] +pub mod apb2enr; +#[doc = "AHB1 peripheral clock enable in low power mode register"] +pub struct AHB1LPENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB1 peripheral clock enable in low power mode register"] +pub mod ahb1lpenr; +#[doc = "AHB2 peripheral clock enable in low power mode register"] +pub struct AHB2LPENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB2 peripheral clock enable in low power mode register"] +pub mod ahb2lpenr; +#[doc = "APB1 peripheral clock enable in low power mode register"] +pub struct APB1LPENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB1 peripheral clock enable in low power mode register"] +pub mod apb1lpenr; +#[doc = "APB2 peripheral clock enabled in low power mode register"] +pub struct APB2LPENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "APB2 peripheral clock enabled in low power mode register"] +pub mod apb2lpenr; +#[doc = "Backup domain control register"] +pub struct BDCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Backup domain control register"] +pub mod bdcr; +#[doc = "clock control & status register"] +pub struct CSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "clock control & status register"] +pub mod csr; +#[doc = "spread spectrum clock generation register"] +pub struct SSCGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "spread spectrum clock generation register"] +pub mod sscgr; +#[doc = "PLLI2S configuration register"] +pub struct PLLI2SCFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "PLLI2S configuration register"] +pub mod plli2scfgr; +#[doc = "peripheral reset register"] +pub struct AHB3RSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "peripheral reset register"] +pub mod ahb3rstr; +#[doc = "AHB3 peripheral clock enable register"] +pub struct AHB3ENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB3 peripheral clock enable register"] +pub mod ahb3enr; +#[doc = "AHB3 peripheral clock enable in low power mode register"] +pub struct AHB3LPENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AHB3 peripheral clock enable in low power mode register"] +pub mod ahb3lpenr; +#[doc = "Dedicated Clocks Configuration Register"] +pub struct DCKCFGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Dedicated Clocks Configuration Register"] +pub mod dckcfgr; +#[doc = "RCC clocks gated enable register"] +pub struct CKGATENR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "RCC clocks gated enable register"] +pub mod ckgatenr; +#[doc = "Dedicated Clocks Configuration Register"] +pub struct DCKCFGR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Dedicated Clocks Configuration Register"] +pub mod dckcfgr2; diff --git a/src/rcc/pllcfgr/mod.rs b/src/rcc/pllcfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..258ab6bdf519921ebd8d704b24c58c64c913a4b3 --- /dev/null +++ b/src/rcc/pllcfgr/mod.rs @@ -0,0 +1,1403 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PLLCFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PLLQ3R { + bits: bool, +} +impl PLLQ3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLQ2R { + bits: bool, +} +impl PLLQ2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLQ1R { + bits: bool, +} +impl PLLQ1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLQ0R { + bits: bool, +} +impl PLLQ0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLSRCR { + bits: bool, +} +impl PLLSRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLP1R { + bits: bool, +} +impl PLLP1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLP0R { + bits: bool, +} +impl PLLP0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN8R { + bits: bool, +} +impl PLLN8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN7R { + bits: bool, +} +impl PLLN7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN6R { + bits: bool, +} +impl PLLN6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN5R { + bits: bool, +} +impl PLLN5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN4R { + bits: bool, +} +impl PLLN4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN3R { + bits: bool, +} +impl PLLN3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN2R { + bits: bool, +} +impl PLLN2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN1R { + bits: bool, +} +impl PLLN1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLN0R { + bits: bool, +} +impl PLLN0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM5R { + bits: bool, +} +impl PLLM5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM4R { + bits: bool, +} +impl PLLM4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM3R { + bits: bool, +} +impl PLLM3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM2R { + bits: bool, +} +impl PLLM2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM1R { + bits: bool, +} +impl PLLM1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLM0R { + bits: bool, +} +impl PLLM0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLRR { + bits: u8, +} +impl PLLRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PLLQ3W<'a> { + w: &'a mut W, +} +impl<'a> _PLLQ3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 27; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLQ2W<'a> { + w: &'a mut W, +} +impl<'a> _PLLQ2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 26; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLQ1W<'a> { + w: &'a mut W, +} +impl<'a> _PLLQ1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 25; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLQ0W<'a> { + w: &'a mut W, +} +impl<'a> _PLLQ0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLSRCW<'a> { + w: &'a mut W, +} +impl<'a> _PLLSRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLP1W<'a> { + w: &'a mut W, +} +impl<'a> _PLLP1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLP0W<'a> { + w: &'a mut W, +} +impl<'a> _PLLP0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN8W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN7W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN7W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN6W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN6W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN5W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN4W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN3W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN2W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN1W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLN0W<'a> { + w: &'a mut W, +} +impl<'a> _PLLN0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM5W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM5W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM4W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM3W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM2W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM1W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLM0W<'a> { + w: &'a mut W, +} +impl<'a> _PLLM0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLRW<'a> { + w: &'a mut W, +} +impl<'a> _PLLRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 27 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq3(&self) -> PLLQ3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 27; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLQ3R { bits } + } + #[doc = "Bit 26 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq2(&self) -> PLLQ2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 26; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLQ2R { bits } + } + #[doc = "Bit 25 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq1(&self) -> PLLQ1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 25; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLQ1R { bits } + } + #[doc = "Bit 24 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq0(&self) -> PLLQ0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLQ0R { bits } + } + #[doc = "Bit 22 - Main PLL(PLL) and audio PLL (PLLI2S) entry clock source"] + #[inline] + pub fn pllsrc(&self) -> PLLSRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLSRCR { bits } + } + #[doc = "Bit 17 - Main PLL (PLL) division factor for main system clock"] + #[inline] + pub fn pllp1(&self) -> PLLP1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLP1R { bits } + } + #[doc = "Bit 16 - Main PLL (PLL) division factor for main system clock"] + #[inline] + pub fn pllp0(&self) -> PLLP0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLP0R { bits } + } + #[doc = "Bit 14 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln8(&self) -> PLLN8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN8R { bits } + } + #[doc = "Bit 13 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln7(&self) -> PLLN7R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN7R { bits } + } + #[doc = "Bit 12 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln6(&self) -> PLLN6R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN6R { bits } + } + #[doc = "Bit 11 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln5(&self) -> PLLN5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN5R { bits } + } + #[doc = "Bit 10 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln4(&self) -> PLLN4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN4R { bits } + } + #[doc = "Bit 9 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln3(&self) -> PLLN3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN3R { bits } + } + #[doc = "Bit 8 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln2(&self) -> PLLN2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN2R { bits } + } + #[doc = "Bit 7 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln1(&self) -> PLLN1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN1R { bits } + } + #[doc = "Bit 6 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln0(&self) -> PLLN0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLN0R { bits } + } + #[doc = "Bit 5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm5(&self) -> PLLM5R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM5R { bits } + } + #[doc = "Bit 4 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm4(&self) -> PLLM4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM4R { bits } + } + #[doc = "Bit 3 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm3(&self) -> PLLM3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM3R { bits } + } + #[doc = "Bit 2 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm2(&self) -> PLLM2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM2R { bits } + } + #[doc = "Bit 1 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm1(&self) -> PLLM1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM1R { bits } + } + #[doc = "Bit 0 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm0(&self) -> PLLM0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLM0R { bits } + } + #[doc = "Bits 28:30 - Main PLL (PLL) division factor for I2S, DFSDM clocks"] + #[inline] + pub fn pllr(&self) -> PLLRR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLLRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 603992080 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 27 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq3(&mut self) -> _PLLQ3W { + _PLLQ3W { w: self } + } + #[doc = "Bit 26 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq2(&mut self) -> _PLLQ2W { + _PLLQ2W { w: self } + } + #[doc = "Bit 25 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq1(&mut self) -> _PLLQ1W { + _PLLQ1W { w: self } + } + #[doc = "Bit 24 - Main PLL (PLL) division factor for USB OTG FS, SDIO and random number generator clocks"] + #[inline] + pub fn pllq0(&mut self) -> _PLLQ0W { + _PLLQ0W { w: self } + } + #[doc = "Bit 22 - Main PLL(PLL) and audio PLL (PLLI2S) entry clock source"] + #[inline] + pub fn pllsrc(&mut self) -> _PLLSRCW { + _PLLSRCW { w: self } + } + #[doc = "Bit 17 - Main PLL (PLL) division factor for main system clock"] + #[inline] + pub fn pllp1(&mut self) -> _PLLP1W { + _PLLP1W { w: self } + } + #[doc = "Bit 16 - Main PLL (PLL) division factor for main system clock"] + #[inline] + pub fn pllp0(&mut self) -> _PLLP0W { + _PLLP0W { w: self } + } + #[doc = "Bit 14 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln8(&mut self) -> _PLLN8W { + _PLLN8W { w: self } + } + #[doc = "Bit 13 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln7(&mut self) -> _PLLN7W { + _PLLN7W { w: self } + } + #[doc = "Bit 12 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln6(&mut self) -> _PLLN6W { + _PLLN6W { w: self } + } + #[doc = "Bit 11 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln5(&mut self) -> _PLLN5W { + _PLLN5W { w: self } + } + #[doc = "Bit 10 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln4(&mut self) -> _PLLN4W { + _PLLN4W { w: self } + } + #[doc = "Bit 9 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln3(&mut self) -> _PLLN3W { + _PLLN3W { w: self } + } + #[doc = "Bit 8 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln2(&mut self) -> _PLLN2W { + _PLLN2W { w: self } + } + #[doc = "Bit 7 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln1(&mut self) -> _PLLN1W { + _PLLN1W { w: self } + } + #[doc = "Bit 6 - Main PLL (PLL) multiplication factor for VCO"] + #[inline] + pub fn plln0(&mut self) -> _PLLN0W { + _PLLN0W { w: self } + } + #[doc = "Bit 5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm5(&mut self) -> _PLLM5W { + _PLLM5W { w: self } + } + #[doc = "Bit 4 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm4(&mut self) -> _PLLM4W { + _PLLM4W { w: self } + } + #[doc = "Bit 3 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm3(&mut self) -> _PLLM3W { + _PLLM3W { w: self } + } + #[doc = "Bit 2 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm2(&mut self) -> _PLLM2W { + _PLLM2W { w: self } + } + #[doc = "Bit 1 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm1(&mut self) -> _PLLM1W { + _PLLM1W { w: self } + } + #[doc = "Bit 0 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn pllm0(&mut self) -> _PLLM0W { + _PLLM0W { w: self } + } + #[doc = "Bits 28:30 - Main PLL (PLL) division factor for I2S, DFSDM clocks"] + #[inline] + pub fn pllr(&mut self) -> _PLLRW { + _PLLRW { w: self } + } +} diff --git a/src/rcc/plli2scfgr/mod.rs b/src/rcc/plli2scfgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..587cefb4b06d99b36a58ddf8832046c477962273 --- /dev/null +++ b/src/rcc/plli2scfgr/mod.rs @@ -0,0 +1,287 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PLLI2SCFGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SRR { + bits: u8, +} +impl PLLI2SRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SNR { + bits: u16, +} +impl PLLI2SNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SMR { + bits: u8, +} +impl PLLI2SMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SSRCR { + bits: bool, +} +impl PLLI2SSRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PLLI2SQR { + bits: u8, +} +impl PLLI2SQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SRW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SNW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 511; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SMW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SSRCW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SSRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PLLI2SQW<'a> { + w: &'a mut W, +} +impl<'a> _PLLI2SQW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 28:30 - PLLI2S division factor for I2S clocks"] + #[inline] + pub fn plli2sr(&self) -> PLLI2SRR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLLI2SRR { bits } + } + #[doc = "Bits 6:14 - PLLI2S multiplication factor for VCO"] + #[inline] + pub fn plli2sn(&self) -> PLLI2SNR { + let bits = { + const MASK: u16 = 511; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PLLI2SNR { bits } + } + #[doc = "Bits 0:5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn plli2sm(&self) -> PLLI2SMR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLLI2SMR { bits } + } + #[doc = "Bit 22 - PLLI2S entry clock source"] + #[inline] + pub fn plli2ssrc(&self) -> PLLI2SSRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PLLI2SSRCR { bits } + } + #[doc = "Bits 24:27 - PLLI2S division factor for USB OTG FS/SDIO/RNG clock"] + #[inline] + pub fn plli2sq(&self) -> PLLI2SQR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PLLI2SQR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 536883200 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 28:30 - PLLI2S division factor for I2S clocks"] + #[inline] + pub fn plli2sr(&mut self) -> _PLLI2SRW { + _PLLI2SRW { w: self } + } + #[doc = "Bits 6:14 - PLLI2S multiplication factor for VCO"] + #[inline] + pub fn plli2sn(&mut self) -> _PLLI2SNW { + _PLLI2SNW { w: self } + } + #[doc = "Bits 0:5 - Division factor for the main PLL (PLL) and audio PLL (PLLI2S) input clock"] + #[inline] + pub fn plli2sm(&mut self) -> _PLLI2SMW { + _PLLI2SMW { w: self } + } + #[doc = "Bit 22 - PLLI2S entry clock source"] + #[inline] + pub fn plli2ssrc(&mut self) -> _PLLI2SSRCW { + _PLLI2SSRCW { w: self } + } + #[doc = "Bits 24:27 - PLLI2S division factor for USB OTG FS/SDIO/RNG clock"] + #[inline] + pub fn plli2sq(&mut self) -> _PLLI2SQW { + _PLLI2SQW { w: self } + } +} diff --git a/src/rcc/sscgr/mod.rs b/src/rcc/sscgr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..362d0e92484b00171a2d774f63ff1399a123da6b --- /dev/null +++ b/src/rcc/sscgr/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SSCGR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SSCGENR { + bits: bool, +} +impl SSCGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SPREADSELR { + bits: bool, +} +impl SPREADSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INCSTEPR { + bits: u16, +} +impl INCSTEPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODPERR { + bits: u16, +} +impl MODPERR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SSCGENW<'a> { + w: &'a mut W, +} +impl<'a> _SSCGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SPREADSELW<'a> { + w: &'a mut W, +} +impl<'a> _SPREADSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INCSTEPW<'a> { + w: &'a mut W, +} +impl<'a> _INCSTEPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 32767; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODPERW<'a> { + w: &'a mut W, +} +impl<'a> _MODPERW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 8191; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Spread spectrum modulation enable"] + #[inline] + pub fn sscgen(&self) -> SSCGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SSCGENR { bits } + } + #[doc = "Bit 30 - Spread Select"] + #[inline] + pub fn spreadsel(&self) -> SPREADSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SPREADSELR { bits } + } + #[doc = "Bits 13:27 - Incrementation step"] + #[inline] + pub fn incstep(&self) -> INCSTEPR { + let bits = { + const MASK: u16 = 32767; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + INCSTEPR { bits } + } + #[doc = "Bits 0:12 - Modulation period"] + #[inline] + pub fn modper(&self) -> MODPERR { + let bits = { + const MASK: u16 = 8191; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + MODPERR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Spread spectrum modulation enable"] + #[inline] + pub fn sscgen(&mut self) -> _SSCGENW { + _SSCGENW { w: self } + } + #[doc = "Bit 30 - Spread Select"] + #[inline] + pub fn spreadsel(&mut self) -> _SPREADSELW { + _SPREADSELW { w: self } + } + #[doc = "Bits 13:27 - Incrementation step"] + #[inline] + pub fn incstep(&mut self) -> _INCSTEPW { + _INCSTEPW { w: self } + } + #[doc = "Bits 0:12 - Modulation period"] + #[inline] + pub fn modper(&mut self) -> _MODPERW { + _MODPERW { w: self } + } +} diff --git a/src/rng/cr/mod.rs b/src/rng/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6bb98c6e6b0ba37605e44af327318a4ae72d8671 --- /dev/null +++ b/src/rng/cr/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IER { + bits: bool, +} +impl IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RNGENR { + bits: bool, +} +impl RNGENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _IEW<'a> { + w: &'a mut W, +} +impl<'a> _IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RNGENW<'a> { + w: &'a mut W, +} +impl<'a> _RNGENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 3 - Interrupt enable"] + #[inline] + pub fn ie(&self) -> IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IER { bits } + } + #[doc = "Bit 2 - Random number generator enable"] + #[inline] + pub fn rngen(&self) -> RNGENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RNGENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Interrupt enable"] + #[inline] + pub fn ie(&mut self) -> _IEW { + _IEW { w: self } + } + #[doc = "Bit 2 - Random number generator enable"] + #[inline] + pub fn rngen(&mut self) -> _RNGENW { + _RNGENW { w: self } + } +} diff --git a/src/rng/dr/mod.rs b/src/rng/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..09844b23a321b567f463e2dd2a58d90c6223d04a --- /dev/null +++ b/src/rng/dr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RNDATAR { + bits: u32, +} +impl RNDATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Random data"] + #[inline] + pub fn rndata(&self) -> RNDATAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + RNDATAR { bits } + } +} diff --git a/src/rng/mod.rs b/src/rng/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f914bbe253e9658d94ef23c3cbc699cbd3c8fd50 --- /dev/null +++ b/src/rng/mod.rs @@ -0,0 +1,28 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register"] + pub cr: CR, + #[doc = "0x04 - status register"] + pub sr: SR, + #[doc = "0x08 - data register"] + pub dr: DR, +} +#[doc = "control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register"] +pub mod cr; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data register"] +pub mod dr; diff --git a/src/rng/sr/mod.rs b/src/rng/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..dc14c2a94314246a48d11aae00d8ef1cb800eab0 --- /dev/null +++ b/src/rng/sr/mod.rs @@ -0,0 +1,275 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SEISR { + bits: bool, +} +impl SEISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CEISR { + bits: bool, +} +impl CEISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SECSR { + bits: bool, +} +impl SECSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CECSR { + bits: bool, +} +impl CECSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DRDYR { + bits: bool, +} +impl DRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SEISW<'a> { + w: &'a mut W, +} +impl<'a> _SEISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CEISW<'a> { + w: &'a mut W, +} +impl<'a> _CEISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Seed error interrupt status"] + #[inline] + pub fn seis(&self) -> SEISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SEISR { bits } + } + #[doc = "Bit 5 - Clock error interrupt status"] + #[inline] + pub fn ceis(&self) -> CEISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CEISR { bits } + } + #[doc = "Bit 2 - Seed error current status"] + #[inline] + pub fn secs(&self) -> SECSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SECSR { bits } + } + #[doc = "Bit 1 - Clock error current status"] + #[inline] + pub fn cecs(&self) -> CECSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CECSR { bits } + } + #[doc = "Bit 0 - Data ready"] + #[inline] + pub fn drdy(&self) -> DRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DRDYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Seed error interrupt status"] + #[inline] + pub fn seis(&mut self) -> _SEISW { + _SEISW { w: self } + } + #[doc = "Bit 5 - Clock error interrupt status"] + #[inline] + pub fn ceis(&mut self) -> _CEISW { + _CEISW { w: self } + } +} diff --git a/src/rtc/alrmar/mod.rs b/src/rtc/alrmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c396a10a277466be6797fb27f0afef15c51d965d --- /dev/null +++ b/src/rtc/alrmar/mod.rs @@ -0,0 +1,746 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ALRMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MSK4R { + bits: bool, +} +impl MSK4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WDSELR { + bits: bool, +} +impl WDSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTR { + bits: u8, +} +impl DTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DUR { + bits: u8, +} +impl DUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK3R { + bits: bool, +} +impl MSK3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PMR { + bits: bool, +} +impl PMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTR { + bits: u8, +} +impl HTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HUR { + bits: u8, +} +impl HUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK2R { + bits: bool, +} +impl MSK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MNTR { + bits: u8, +} +impl MNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNUR { + bits: u8, +} +impl MNUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK1R { + bits: bool, +} +impl MSK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STR { + bits: u8, +} +impl STR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SUR { + bits: u8, +} +impl SUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MSK4W<'a> { + w: &'a mut W, +} +impl<'a> _MSK4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDSELW<'a> { + w: &'a mut W, +} +impl<'a> _WDSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTW<'a> { + w: &'a mut W, +} +impl<'a> _DTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DUW<'a> { + w: &'a mut W, +} +impl<'a> _DUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK3W<'a> { + w: &'a mut W, +} +impl<'a> _MSK3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PMW<'a> { + w: &'a mut W, +} +impl<'a> _PMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTW<'a> { + w: &'a mut W, +} +impl<'a> _HTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HUW<'a> { + w: &'a mut W, +} +impl<'a> _HUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK2W<'a> { + w: &'a mut W, +} +impl<'a> _MSK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNTW<'a> { + w: &'a mut W, +} +impl<'a> _MNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNUW<'a> { + w: &'a mut W, +} +impl<'a> _MNUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK1W<'a> { + w: &'a mut W, +} +impl<'a> _MSK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STW<'a> { + w: &'a mut W, +} +impl<'a> _STW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SUW<'a> { + w: &'a mut W, +} +impl<'a> _SUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Alarm A date mask"] + #[inline] + pub fn msk4(&self) -> MSK4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK4R { bits } + } + #[doc = "Bit 30 - Week day selection"] + #[inline] + pub fn wdsel(&self) -> WDSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDSELR { bits } + } + #[doc = "Bits 28:29 - Date tens in BCD format"] + #[inline] + pub fn dt(&self) -> DTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTR { bits } + } + #[doc = "Bits 24:27 - Date units or day in BCD format"] + #[inline] + pub fn du(&self) -> DUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DUR { bits } + } + #[doc = "Bit 23 - Alarm A hours mask"] + #[inline] + pub fn msk3(&self) -> MSK3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK3R { bits } + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&self) -> PMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PMR { bits } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&self) -> HTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HTR { bits } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&self) -> HUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HUR { bits } + } + #[doc = "Bit 15 - Alarm A minutes mask"] + #[inline] + pub fn msk2(&self) -> MSK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK2R { bits } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&self) -> MNTR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNTR { bits } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&self) -> MNUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNUR { bits } + } + #[doc = "Bit 7 - Alarm A seconds mask"] + #[inline] + pub fn msk1(&self) -> MSK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK1R { bits } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&self) -> STR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STR { bits } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&self) -> SUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SUR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Alarm A date mask"] + #[inline] + pub fn msk4(&mut self) -> _MSK4W { + _MSK4W { w: self } + } + #[doc = "Bit 30 - Week day selection"] + #[inline] + pub fn wdsel(&mut self) -> _WDSELW { + _WDSELW { w: self } + } + #[doc = "Bits 28:29 - Date tens in BCD format"] + #[inline] + pub fn dt(&mut self) -> _DTW { + _DTW { w: self } + } + #[doc = "Bits 24:27 - Date units or day in BCD format"] + #[inline] + pub fn du(&mut self) -> _DUW { + _DUW { w: self } + } + #[doc = "Bit 23 - Alarm A hours mask"] + #[inline] + pub fn msk3(&mut self) -> _MSK3W { + _MSK3W { w: self } + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&mut self) -> _PMW { + _PMW { w: self } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&mut self) -> _HTW { + _HTW { w: self } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&mut self) -> _HUW { + _HUW { w: self } + } + #[doc = "Bit 15 - Alarm A minutes mask"] + #[inline] + pub fn msk2(&mut self) -> _MSK2W { + _MSK2W { w: self } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&mut self) -> _MNTW { + _MNTW { w: self } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&mut self) -> _MNUW { + _MNUW { w: self } + } + #[doc = "Bit 7 - Alarm A seconds mask"] + #[inline] + pub fn msk1(&mut self) -> _MSK1W { + _MSK1W { w: self } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&mut self) -> _STW { + _STW { w: self } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&mut self) -> _SUW { + _SUW { w: self } + } +} diff --git a/src/rtc/alrmassr/mod.rs b/src/rtc/alrmassr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..24c672a9f3dcfec7f5834c9e5595befeb5d93e00 --- /dev/null +++ b/src/rtc/alrmassr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ALRMASSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MASKSSR { + bits: u8, +} +impl MASKSSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SSR { + bits: u16, +} +impl SSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MASKSSW<'a> { + w: &'a mut W, +} +impl<'a> _MASKSSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSW<'a> { + w: &'a mut W, +} +impl<'a> _SSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] + #[inline] + pub fn maskss(&self) -> MASKSSR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MASKSSR { bits } + } + #[doc = "Bits 0:14 - Sub seconds value"] + #[inline] + pub fn ss(&self) -> SSR { + let bits = { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] + #[inline] + pub fn maskss(&mut self) -> _MASKSSW { + _MASKSSW { w: self } + } + #[doc = "Bits 0:14 - Sub seconds value"] + #[inline] + pub fn ss(&mut self) -> _SSW { + _SSW { w: self } + } +} diff --git a/src/rtc/alrmbr/mod.rs b/src/rtc/alrmbr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a0287661696e70b10470c237b99b036899f6496b --- /dev/null +++ b/src/rtc/alrmbr/mod.rs @@ -0,0 +1,746 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ALRMBR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MSK4R { + bits: bool, +} +impl MSK4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WDSELR { + bits: bool, +} +impl WDSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTR { + bits: u8, +} +impl DTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DUR { + bits: u8, +} +impl DUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK3R { + bits: bool, +} +impl MSK3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PMR { + bits: bool, +} +impl PMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTR { + bits: u8, +} +impl HTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HUR { + bits: u8, +} +impl HUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK2R { + bits: bool, +} +impl MSK2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MNTR { + bits: u8, +} +impl MNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNUR { + bits: u8, +} +impl MNUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSK1R { + bits: bool, +} +impl MSK1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STR { + bits: u8, +} +impl STR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SUR { + bits: u8, +} +impl SUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MSK4W<'a> { + w: &'a mut W, +} +impl<'a> _MSK4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDSELW<'a> { + w: &'a mut W, +} +impl<'a> _WDSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 30; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTW<'a> { + w: &'a mut W, +} +impl<'a> _DTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DUW<'a> { + w: &'a mut W, +} +impl<'a> _DUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK3W<'a> { + w: &'a mut W, +} +impl<'a> _MSK3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PMW<'a> { + w: &'a mut W, +} +impl<'a> _PMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTW<'a> { + w: &'a mut W, +} +impl<'a> _HTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HUW<'a> { + w: &'a mut W, +} +impl<'a> _HUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK2W<'a> { + w: &'a mut W, +} +impl<'a> _MSK2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNTW<'a> { + w: &'a mut W, +} +impl<'a> _MNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNUW<'a> { + w: &'a mut W, +} +impl<'a> _MNUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSK1W<'a> { + w: &'a mut W, +} +impl<'a> _MSK1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STW<'a> { + w: &'a mut W, +} +impl<'a> _STW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SUW<'a> { + w: &'a mut W, +} +impl<'a> _SUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 31 - Alarm B date mask"] + #[inline] + pub fn msk4(&self) -> MSK4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK4R { bits } + } + #[doc = "Bit 30 - Week day selection"] + #[inline] + pub fn wdsel(&self) -> WDSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 30; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDSELR { bits } + } + #[doc = "Bits 28:29 - Date tens in BCD format"] + #[inline] + pub fn dt(&self) -> DTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 28; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTR { bits } + } + #[doc = "Bits 24:27 - Date units or day in BCD format"] + #[inline] + pub fn du(&self) -> DUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DUR { bits } + } + #[doc = "Bit 23 - Alarm B hours mask"] + #[inline] + pub fn msk3(&self) -> MSK3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK3R { bits } + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&self) -> PMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PMR { bits } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&self) -> HTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HTR { bits } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&self) -> HUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HUR { bits } + } + #[doc = "Bit 15 - Alarm B minutes mask"] + #[inline] + pub fn msk2(&self) -> MSK2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK2R { bits } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&self) -> MNTR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNTR { bits } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&self) -> MNUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNUR { bits } + } + #[doc = "Bit 7 - Alarm B seconds mask"] + #[inline] + pub fn msk1(&self) -> MSK1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSK1R { bits } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&self) -> STR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STR { bits } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&self) -> SUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SUR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Alarm B date mask"] + #[inline] + pub fn msk4(&mut self) -> _MSK4W { + _MSK4W { w: self } + } + #[doc = "Bit 30 - Week day selection"] + #[inline] + pub fn wdsel(&mut self) -> _WDSELW { + _WDSELW { w: self } + } + #[doc = "Bits 28:29 - Date tens in BCD format"] + #[inline] + pub fn dt(&mut self) -> _DTW { + _DTW { w: self } + } + #[doc = "Bits 24:27 - Date units or day in BCD format"] + #[inline] + pub fn du(&mut self) -> _DUW { + _DUW { w: self } + } + #[doc = "Bit 23 - Alarm B hours mask"] + #[inline] + pub fn msk3(&mut self) -> _MSK3W { + _MSK3W { w: self } + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&mut self) -> _PMW { + _PMW { w: self } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&mut self) -> _HTW { + _HTW { w: self } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&mut self) -> _HUW { + _HUW { w: self } + } + #[doc = "Bit 15 - Alarm B minutes mask"] + #[inline] + pub fn msk2(&mut self) -> _MSK2W { + _MSK2W { w: self } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&mut self) -> _MNTW { + _MNTW { w: self } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&mut self) -> _MNUW { + _MNUW { w: self } + } + #[doc = "Bit 7 - Alarm B seconds mask"] + #[inline] + pub fn msk1(&mut self) -> _MSK1W { + _MSK1W { w: self } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&mut self) -> _STW { + _STW { w: self } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&mut self) -> _SUW { + _SUW { w: self } + } +} diff --git a/src/rtc/alrmbssr/mod.rs b/src/rtc/alrmbssr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..27f14cb93b2ee8386cf12e9e77f9393a627a266d --- /dev/null +++ b/src/rtc/alrmbssr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ALRMBSSR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MASKSSR { + bits: u8, +} +impl MASKSSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SSR { + bits: u16, +} +impl SSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MASKSSW<'a> { + w: &'a mut W, +} +impl<'a> _MASKSSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SSW<'a> { + w: &'a mut W, +} +impl<'a> _SSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] + #[inline] + pub fn maskss(&self) -> MASKSSR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 24; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MASKSSR { bits } + } + #[doc = "Bits 0:14 - Sub seconds value"] + #[inline] + pub fn ss(&self) -> SSR { + let bits = { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] + #[inline] + pub fn maskss(&mut self) -> _MASKSSW { + _MASKSSW { w: self } + } + #[doc = "Bits 0:14 - Sub seconds value"] + #[inline] + pub fn ss(&mut self) -> _SSW { + _SSW { w: self } + } +} diff --git a/src/rtc/bkp0r/mod.rs b/src/rtc/bkp0r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..27f5d449e1ed5cc7c144b6f6c6f18f70f344eeab --- /dev/null +++ b/src/rtc/bkp0r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP0R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp10r/mod.rs b/src/rtc/bkp10r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fa51c7364dc5831a68495b26a435d0a6a9a278f0 --- /dev/null +++ b/src/rtc/bkp10r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP10R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp11r/mod.rs b/src/rtc/bkp11r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..00514501284d1ef32ad7f28e548e64e43ad7d6dc --- /dev/null +++ b/src/rtc/bkp11r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP11R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp12r/mod.rs b/src/rtc/bkp12r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4f993d90ee51455c10520242afe5071a5eec373f --- /dev/null +++ b/src/rtc/bkp12r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP12R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp13r/mod.rs b/src/rtc/bkp13r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1657c05b38943314f8b498c80cbd665c7ef3594c --- /dev/null +++ b/src/rtc/bkp13r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP13R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp14r/mod.rs b/src/rtc/bkp14r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..78faeaa8c23255434b29c23c9693efd9839ae407 --- /dev/null +++ b/src/rtc/bkp14r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP14R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp15r/mod.rs b/src/rtc/bkp15r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6ad6d1c720e5d17b1253dc6650286f047d55a9ac --- /dev/null +++ b/src/rtc/bkp15r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP15R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp16r/mod.rs b/src/rtc/bkp16r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..34fd595fa1dbd86c629f6131067df540d64840e6 --- /dev/null +++ b/src/rtc/bkp16r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP16R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp17r/mod.rs b/src/rtc/bkp17r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c994f87b62851339ec7136ebb5e5ed51da4b6c22 --- /dev/null +++ b/src/rtc/bkp17r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP17R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp18r/mod.rs b/src/rtc/bkp18r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..25b1d7c42b6488d1692fa1060bc107efe056dafe --- /dev/null +++ b/src/rtc/bkp18r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP18R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp19r/mod.rs b/src/rtc/bkp19r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..33ff7c0a31808baba08cd2d4a1c4eaad41acbad0 --- /dev/null +++ b/src/rtc/bkp19r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP19R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp1r/mod.rs b/src/rtc/bkp1r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3907b1c2ffd91b52a77a79de7973cba095c466c5 --- /dev/null +++ b/src/rtc/bkp1r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP1R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp2r/mod.rs b/src/rtc/bkp2r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2731a73f852a94f39943321f33128dc37371ba27 --- /dev/null +++ b/src/rtc/bkp2r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP2R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp3r/mod.rs b/src/rtc/bkp3r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7da166f9ffa4e51e539ad06e1d9a14bd56056998 --- /dev/null +++ b/src/rtc/bkp3r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP3R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp4r/mod.rs b/src/rtc/bkp4r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7db29262d7e403523ed346938280294304042691 --- /dev/null +++ b/src/rtc/bkp4r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP4R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp5r/mod.rs b/src/rtc/bkp5r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e5b020d260d951680c00c2e465f7ef5875aa2166 --- /dev/null +++ b/src/rtc/bkp5r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP5R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp6r/mod.rs b/src/rtc/bkp6r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..570191ee87a5c0e70a14917306306a8ad6308344 --- /dev/null +++ b/src/rtc/bkp6r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP6R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp7r/mod.rs b/src/rtc/bkp7r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f43c2d23326e66638ffa53733c3c81b4f53f8dbd --- /dev/null +++ b/src/rtc/bkp7r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP7R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp8r/mod.rs b/src/rtc/bkp8r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8b2aafd84eaaa0728d5df5098a08b6e5d9cfa11d --- /dev/null +++ b/src/rtc/bkp8r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP8R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/bkp9r/mod.rs b/src/rtc/bkp9r/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6e60b7d2f3a25b622058d20e8dc59bab624ba3eb --- /dev/null +++ b/src/rtc/bkp9r/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BKP9R { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: u32, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + BKPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - BKP"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } +} diff --git a/src/rtc/calibr/mod.rs b/src/rtc/calibr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..165f8879cb9b3603f16f50238cd43fad1afecdd8 --- /dev/null +++ b/src/rtc/calibr/mod.rs @@ -0,0 +1,164 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CALIBR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DCSR { + bits: bool, +} +impl DCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCR { + bits: u8, +} +impl DCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DCSW<'a> { + w: &'a mut W, +} +impl<'a> _DCSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCW<'a> { + w: &'a mut W, +} +impl<'a> _DCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Digital calibration sign"] + #[inline] + pub fn dcs(&self) -> DCSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCSR { bits } + } + #[doc = "Bits 0:4 - Digital calibration"] + #[inline] + pub fn dc(&self) -> DCR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Digital calibration sign"] + #[inline] + pub fn dcs(&mut self) -> _DCSW { + _DCSW { w: self } + } + #[doc = "Bits 0:4 - Digital calibration"] + #[inline] + pub fn dc(&mut self) -> _DCW { + _DCW { w: self } + } +} diff --git a/src/rtc/calr/mod.rs b/src/rtc/calr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d0d71e6468b92caa4d5bf7a90db45b190fae3d6a --- /dev/null +++ b/src/rtc/calr/mod.rs @@ -0,0 +1,282 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CALR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CALPR { + bits: bool, +} +impl CALPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CALW8R { + bits: bool, +} +impl CALW8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CALW16R { + bits: bool, +} +impl CALW16R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CALMR { + bits: u16, +} +impl CALMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CALPW<'a> { + w: &'a mut W, +} +impl<'a> _CALPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CALW8W<'a> { + w: &'a mut W, +} +impl<'a> _CALW8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CALW16W<'a> { + w: &'a mut W, +} +impl<'a> _CALW16W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CALMW<'a> { + w: &'a mut W, +} +impl<'a> _CALMW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 511; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Increase frequency of RTC by 488.5 ppm"] + #[inline] + pub fn calp(&self) -> CALPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CALPR { bits } + } + #[doc = "Bit 14 - Use an 8-second calibration cycle period"] + #[inline] + pub fn calw8(&self) -> CALW8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CALW8R { bits } + } + #[doc = "Bit 13 - Use a 16-second calibration cycle period"] + #[inline] + pub fn calw16(&self) -> CALW16R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CALW16R { bits } + } + #[doc = "Bits 0:8 - Calibration minus"] + #[inline] + pub fn calm(&self) -> CALMR { + let bits = { + const MASK: u16 = 511; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CALMR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Increase frequency of RTC by 488.5 ppm"] + #[inline] + pub fn calp(&mut self) -> _CALPW { + _CALPW { w: self } + } + #[doc = "Bit 14 - Use an 8-second calibration cycle period"] + #[inline] + pub fn calw8(&mut self) -> _CALW8W { + _CALW8W { w: self } + } + #[doc = "Bit 13 - Use a 16-second calibration cycle period"] + #[inline] + pub fn calw16(&mut self) -> _CALW16W { + _CALW16W { w: self } + } + #[doc = "Bits 0:8 - Calibration minus"] + #[inline] + pub fn calm(&mut self) -> _CALMW { + _CALMW { w: self } + } +} diff --git a/src/rtc/cr/mod.rs b/src/rtc/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..55dac8f4861121013218f08c2259df93c098a6ec --- /dev/null +++ b/src/rtc/cr/mod.rs @@ -0,0 +1,1267 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct COER { + bits: bool, +} +impl COER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OSELR { + bits: u8, +} +impl OSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct POLR { + bits: bool, +} +impl POLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct COSELR { + bits: bool, +} +impl COSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: bool, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SUB1HR { + bits: bool, +} +impl SUB1HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADD1HR { + bits: bool, +} +impl ADD1HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSIER { + bits: bool, +} +impl TSIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WUTIER { + bits: bool, +} +impl WUTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRBIER { + bits: bool, +} +impl ALRBIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRAIER { + bits: bool, +} +impl ALRAIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSER { + bits: bool, +} +impl TSER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WUTER { + bits: bool, +} +impl WUTER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRBER { + bits: bool, +} +impl ALRBER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRAER { + bits: bool, +} +impl ALRAER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCER { + bits: bool, +} +impl DCER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FMTR { + bits: bool, +} +impl FMTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BYPSHADR { + bits: bool, +} +impl BYPSHADR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct REFCKONR { + bits: bool, +} +impl REFCKONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSEDGER { + bits: bool, +} +impl TSEDGER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKSELR { + bits: u8, +} +impl WCKSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _COEW<'a> { + w: &'a mut W, +} +impl<'a> _COEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSELW<'a> { + w: &'a mut W, +} +impl<'a> _OSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _POLW<'a> { + w: &'a mut W, +} +impl<'a> _POLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COSELW<'a> { + w: &'a mut W, +} +impl<'a> _COSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SUB1HW<'a> { + w: &'a mut W, +} +impl<'a> _SUB1HW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADD1HW<'a> { + w: &'a mut W, +} +impl<'a> _ADD1HW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSIEW<'a> { + w: &'a mut W, +} +impl<'a> _TSIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WUTIEW<'a> { + w: &'a mut W, +} +impl<'a> _WUTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRBIEW<'a> { + w: &'a mut W, +} +impl<'a> _ALRBIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRAIEW<'a> { + w: &'a mut W, +} +impl<'a> _ALRAIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSEW<'a> { + w: &'a mut W, +} +impl<'a> _TSEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WUTEW<'a> { + w: &'a mut W, +} +impl<'a> _WUTEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRBEW<'a> { + w: &'a mut W, +} +impl<'a> _ALRBEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRAEW<'a> { + w: &'a mut W, +} +impl<'a> _ALRAEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCEW<'a> { + w: &'a mut W, +} +impl<'a> _DCEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FMTW<'a> { + w: &'a mut W, +} +impl<'a> _FMTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BYPSHADW<'a> { + w: &'a mut W, +} +impl<'a> _BYPSHADW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REFCKONW<'a> { + w: &'a mut W, +} +impl<'a> _REFCKONW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSEDGEW<'a> { + w: &'a mut W, +} +impl<'a> _TSEDGEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKSELW<'a> { + w: &'a mut W, +} +impl<'a> _WCKSELW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 23 - Calibration output enable"] + #[inline] + pub fn coe(&self) -> COER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COER { bits } + } + #[doc = "Bits 21:22 - Output selection"] + #[inline] + pub fn osel(&self) -> OSELR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OSELR { bits } + } + #[doc = "Bit 20 - Output polarity"] + #[inline] + pub fn pol(&self) -> POLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + POLR { bits } + } + #[doc = "Bit 19 - Calibration Output selection"] + #[inline] + pub fn cosel(&self) -> COSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COSELR { bits } + } + #[doc = "Bit 18 - Backup"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BKPR { bits } + } + #[doc = "Bit 17 - Subtract 1 hour (winter time change)"] + #[inline] + pub fn sub1h(&self) -> SUB1HR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SUB1HR { bits } + } + #[doc = "Bit 16 - Add 1 hour (summer time change)"] + #[inline] + pub fn add1h(&self) -> ADD1HR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADD1HR { bits } + } + #[doc = "Bit 15 - Time-stamp interrupt enable"] + #[inline] + pub fn tsie(&self) -> TSIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSIER { bits } + } + #[doc = "Bit 14 - Wakeup timer interrupt enable"] + #[inline] + pub fn wutie(&self) -> WUTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUTIER { bits } + } + #[doc = "Bit 13 - Alarm B interrupt enable"] + #[inline] + pub fn alrbie(&self) -> ALRBIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRBIER { bits } + } + #[doc = "Bit 12 - Alarm A interrupt enable"] + #[inline] + pub fn alraie(&self) -> ALRAIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRAIER { bits } + } + #[doc = "Bit 11 - Time stamp enable"] + #[inline] + pub fn tse(&self) -> TSER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSER { bits } + } + #[doc = "Bit 10 - Wakeup timer enable"] + #[inline] + pub fn wute(&self) -> WUTER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUTER { bits } + } + #[doc = "Bit 9 - Alarm B enable"] + #[inline] + pub fn alrbe(&self) -> ALRBER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRBER { bits } + } + #[doc = "Bit 8 - Alarm A enable"] + #[inline] + pub fn alrae(&self) -> ALRAER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRAER { bits } + } + #[doc = "Bit 7 - Coarse digital calibration enable"] + #[inline] + pub fn dce(&self) -> DCER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCER { bits } + } + #[doc = "Bit 6 - Hour format"] + #[inline] + pub fn fmt(&self) -> FMTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FMTR { bits } + } + #[doc = "Bit 5 - Bypass the shadow registers"] + #[inline] + pub fn bypshad(&self) -> BYPSHADR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BYPSHADR { bits } + } + #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"] + #[inline] + pub fn refckon(&self) -> REFCKONR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + REFCKONR { bits } + } + #[doc = "Bit 3 - Time-stamp event active edge"] + #[inline] + pub fn tsedge(&self) -> TSEDGER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSEDGER { bits } + } + #[doc = "Bits 0:2 - Wakeup clock selection"] + #[inline] + pub fn wcksel(&self) -> WCKSELR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WCKSELR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 23 - Calibration output enable"] + #[inline] + pub fn coe(&mut self) -> _COEW { + _COEW { w: self } + } + #[doc = "Bits 21:22 - Output selection"] + #[inline] + pub fn osel(&mut self) -> _OSELW { + _OSELW { w: self } + } + #[doc = "Bit 20 - Output polarity"] + #[inline] + pub fn pol(&mut self) -> _POLW { + _POLW { w: self } + } + #[doc = "Bit 19 - Calibration Output selection"] + #[inline] + pub fn cosel(&mut self) -> _COSELW { + _COSELW { w: self } + } + #[doc = "Bit 18 - Backup"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } + #[doc = "Bit 17 - Subtract 1 hour (winter time change)"] + #[inline] + pub fn sub1h(&mut self) -> _SUB1HW { + _SUB1HW { w: self } + } + #[doc = "Bit 16 - Add 1 hour (summer time change)"] + #[inline] + pub fn add1h(&mut self) -> _ADD1HW { + _ADD1HW { w: self } + } + #[doc = "Bit 15 - Time-stamp interrupt enable"] + #[inline] + pub fn tsie(&mut self) -> _TSIEW { + _TSIEW { w: self } + } + #[doc = "Bit 14 - Wakeup timer interrupt enable"] + #[inline] + pub fn wutie(&mut self) -> _WUTIEW { + _WUTIEW { w: self } + } + #[doc = "Bit 13 - Alarm B interrupt enable"] + #[inline] + pub fn alrbie(&mut self) -> _ALRBIEW { + _ALRBIEW { w: self } + } + #[doc = "Bit 12 - Alarm A interrupt enable"] + #[inline] + pub fn alraie(&mut self) -> _ALRAIEW { + _ALRAIEW { w: self } + } + #[doc = "Bit 11 - Time stamp enable"] + #[inline] + pub fn tse(&mut self) -> _TSEW { + _TSEW { w: self } + } + #[doc = "Bit 10 - Wakeup timer enable"] + #[inline] + pub fn wute(&mut self) -> _WUTEW { + _WUTEW { w: self } + } + #[doc = "Bit 9 - Alarm B enable"] + #[inline] + pub fn alrbe(&mut self) -> _ALRBEW { + _ALRBEW { w: self } + } + #[doc = "Bit 8 - Alarm A enable"] + #[inline] + pub fn alrae(&mut self) -> _ALRAEW { + _ALRAEW { w: self } + } + #[doc = "Bit 7 - Coarse digital calibration enable"] + #[inline] + pub fn dce(&mut self) -> _DCEW { + _DCEW { w: self } + } + #[doc = "Bit 6 - Hour format"] + #[inline] + pub fn fmt(&mut self) -> _FMTW { + _FMTW { w: self } + } + #[doc = "Bit 5 - Bypass the shadow registers"] + #[inline] + pub fn bypshad(&mut self) -> _BYPSHADW { + _BYPSHADW { w: self } + } + #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"] + #[inline] + pub fn refckon(&mut self) -> _REFCKONW { + _REFCKONW { w: self } + } + #[doc = "Bit 3 - Time-stamp event active edge"] + #[inline] + pub fn tsedge(&mut self) -> _TSEDGEW { + _TSEDGEW { w: self } + } + #[doc = "Bits 0:2 - Wakeup clock selection"] + #[inline] + pub fn wcksel(&mut self) -> _WCKSELW { + _WCKSELW { w: self } + } +} diff --git a/src/rtc/dr/mod.rs b/src/rtc/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..deb63457ccc02403c8ba4db66c576ffe80d50129 --- /dev/null +++ b/src/rtc/dr/mod.rs @@ -0,0 +1,369 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct YTR { + bits: u8, +} +impl YTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct YUR { + bits: u8, +} +impl YUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct WDUR { + bits: u8, +} +impl WDUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTR { + bits: bool, +} +impl MTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUR { + bits: u8, +} +impl MUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTR { + bits: u8, +} +impl DTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DUR { + bits: u8, +} +impl DUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _YTW<'a> { + w: &'a mut W, +} +impl<'a> _YTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _YUW<'a> { + w: &'a mut W, +} +impl<'a> _YUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDUW<'a> { + w: &'a mut W, +} +impl<'a> _WDUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MTW<'a> { + w: &'a mut W, +} +impl<'a> _MTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUW<'a> { + w: &'a mut W, +} +impl<'a> _MUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTW<'a> { + w: &'a mut W, +} +impl<'a> _DTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DUW<'a> { + w: &'a mut W, +} +impl<'a> _DUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:23 - Year tens in BCD format"] + #[inline] + pub fn yt(&self) -> YTR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + YTR { bits } + } + #[doc = "Bits 16:19 - Year units in BCD format"] + #[inline] + pub fn yu(&self) -> YUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + YUR { bits } + } + #[doc = "Bits 13:15 - Week day units"] + #[inline] + pub fn wdu(&self) -> WDUR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WDUR { bits } + } + #[doc = "Bit 12 - Month tens in BCD format"] + #[inline] + pub fn mt(&self) -> MTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MTR { bits } + } + #[doc = "Bits 8:11 - Month units in BCD format"] + #[inline] + pub fn mu(&self) -> MUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MUR { bits } + } + #[doc = "Bits 4:5 - Date tens in BCD format"] + #[inline] + pub fn dt(&self) -> DTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTR { bits } + } + #[doc = "Bits 0:3 - Date units in BCD format"] + #[inline] + pub fn du(&self) -> DUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DUR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 8449 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:23 - Year tens in BCD format"] + #[inline] + pub fn yt(&mut self) -> _YTW { + _YTW { w: self } + } + #[doc = "Bits 16:19 - Year units in BCD format"] + #[inline] + pub fn yu(&mut self) -> _YUW { + _YUW { w: self } + } + #[doc = "Bits 13:15 - Week day units"] + #[inline] + pub fn wdu(&mut self) -> _WDUW { + _WDUW { w: self } + } + #[doc = "Bit 12 - Month tens in BCD format"] + #[inline] + pub fn mt(&mut self) -> _MTW { + _MTW { w: self } + } + #[doc = "Bits 8:11 - Month units in BCD format"] + #[inline] + pub fn mu(&mut self) -> _MUW { + _MUW { w: self } + } + #[doc = "Bits 4:5 - Date tens in BCD format"] + #[inline] + pub fn dt(&mut self) -> _DTW { + _DTW { w: self } + } + #[doc = "Bits 0:3 - Date units in BCD format"] + #[inline] + pub fn du(&mut self) -> _DUW { + _DUW { w: self } + } +} diff --git a/src/rtc/isr/mod.rs b/src/rtc/isr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1187772b7c154802e6096e3b8960e1a7d868903c --- /dev/null +++ b/src/rtc/isr/mod.rs @@ -0,0 +1,840 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ISR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ALRAWFR { + bits: bool, +} +impl ALRAWFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRBWFR { + bits: bool, +} +impl ALRBWFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WUTWFR { + bits: bool, +} +impl WUTWFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SHPFR { + bits: bool, +} +impl SHPFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INITSR { + bits: bool, +} +impl INITSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RSFR { + bits: bool, +} +impl RSFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INITFR { + bits: bool, +} +impl INITFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct INITR { + bits: bool, +} +impl INITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRAFR { + bits: bool, +} +impl ALRAFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ALRBFR { + bits: bool, +} +impl ALRBFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WUTFR { + bits: bool, +} +impl WUTFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSFR { + bits: bool, +} +impl TSFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSOVFR { + bits: bool, +} +impl TSOVFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP1FR { + bits: bool, +} +impl TAMP1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP2FR { + bits: bool, +} +impl TAMP2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RECALPFR { + bits: bool, +} +impl RECALPFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SHPFW<'a> { + w: &'a mut W, +} +impl<'a> _SHPFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RSFW<'a> { + w: &'a mut W, +} +impl<'a> _RSFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _INITW<'a> { + w: &'a mut W, +} +impl<'a> _INITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRAFW<'a> { + w: &'a mut W, +} +impl<'a> _ALRAFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ALRBFW<'a> { + w: &'a mut W, +} +impl<'a> _ALRBFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WUTFW<'a> { + w: &'a mut W, +} +impl<'a> _WUTFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSFW<'a> { + w: &'a mut W, +} +impl<'a> _TSFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSOVFW<'a> { + w: &'a mut W, +} +impl<'a> _TSOVFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP1FW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP1FW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP2FW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP2FW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Alarm A write flag"] + #[inline] + pub fn alrawf(&self) -> ALRAWFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRAWFR { bits } + } + #[doc = "Bit 1 - Alarm B write flag"] + #[inline] + pub fn alrbwf(&self) -> ALRBWFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRBWFR { bits } + } + #[doc = "Bit 2 - Wakeup timer write flag"] + #[inline] + pub fn wutwf(&self) -> WUTWFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUTWFR { bits } + } + #[doc = "Bit 3 - Shift operation pending"] + #[inline] + pub fn shpf(&self) -> SHPFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SHPFR { bits } + } + #[doc = "Bit 4 - Initialization status flag"] + #[inline] + pub fn inits(&self) -> INITSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INITSR { bits } + } + #[doc = "Bit 5 - Registers synchronization flag"] + #[inline] + pub fn rsf(&self) -> RSFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RSFR { bits } + } + #[doc = "Bit 6 - Initialization flag"] + #[inline] + pub fn initf(&self) -> INITFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INITFR { bits } + } + #[doc = "Bit 7 - Initialization mode"] + #[inline] + pub fn init(&self) -> INITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + INITR { bits } + } + #[doc = "Bit 8 - Alarm A flag"] + #[inline] + pub fn alraf(&self) -> ALRAFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRAFR { bits } + } + #[doc = "Bit 9 - Alarm B flag"] + #[inline] + pub fn alrbf(&self) -> ALRBFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALRBFR { bits } + } + #[doc = "Bit 10 - Wakeup timer flag"] + #[inline] + pub fn wutf(&self) -> WUTFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WUTFR { bits } + } + #[doc = "Bit 11 - Time-stamp flag"] + #[inline] + pub fn tsf(&self) -> TSFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSFR { bits } + } + #[doc = "Bit 12 - Time-stamp overflow flag"] + #[inline] + pub fn tsovf(&self) -> TSOVFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSOVFR { bits } + } + #[doc = "Bit 13 - Tamper detection flag"] + #[inline] + pub fn tamp1f(&self) -> TAMP1FR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP1FR { bits } + } + #[doc = "Bit 14 - TAMPER2 detection flag"] + #[inline] + pub fn tamp2f(&self) -> TAMP2FR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP2FR { bits } + } + #[doc = "Bit 16 - Recalibration pending Flag"] + #[inline] + pub fn recalpf(&self) -> RECALPFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RECALPFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 7 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Shift operation pending"] + #[inline] + pub fn shpf(&mut self) -> _SHPFW { + _SHPFW { w: self } + } + #[doc = "Bit 5 - Registers synchronization flag"] + #[inline] + pub fn rsf(&mut self) -> _RSFW { + _RSFW { w: self } + } + #[doc = "Bit 7 - Initialization mode"] + #[inline] + pub fn init(&mut self) -> _INITW { + _INITW { w: self } + } + #[doc = "Bit 8 - Alarm A flag"] + #[inline] + pub fn alraf(&mut self) -> _ALRAFW { + _ALRAFW { w: self } + } + #[doc = "Bit 9 - Alarm B flag"] + #[inline] + pub fn alrbf(&mut self) -> _ALRBFW { + _ALRBFW { w: self } + } + #[doc = "Bit 10 - Wakeup timer flag"] + #[inline] + pub fn wutf(&mut self) -> _WUTFW { + _WUTFW { w: self } + } + #[doc = "Bit 11 - Time-stamp flag"] + #[inline] + pub fn tsf(&mut self) -> _TSFW { + _TSFW { w: self } + } + #[doc = "Bit 12 - Time-stamp overflow flag"] + #[inline] + pub fn tsovf(&mut self) -> _TSOVFW { + _TSOVFW { w: self } + } + #[doc = "Bit 13 - Tamper detection flag"] + #[inline] + pub fn tamp1f(&mut self) -> _TAMP1FW { + _TAMP1FW { w: self } + } + #[doc = "Bit 14 - TAMPER2 detection flag"] + #[inline] + pub fn tamp2f(&mut self) -> _TAMP2FW { + _TAMP2FW { w: self } + } +} diff --git a/src/rtc/mod.rs b/src/rtc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..185f92d95c686421c94fdc5f4658daa465dc8721 --- /dev/null +++ b/src/rtc/mod.rs @@ -0,0 +1,317 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - time register"] + pub tr: TR, + #[doc = "0x04 - date register"] + pub dr: DR, + #[doc = "0x08 - control register"] + pub cr: CR, + #[doc = "0x0c - initialization and status register"] + pub isr: ISR, + #[doc = "0x10 - prescaler register"] + pub prer: PRER, + #[doc = "0x14 - wakeup timer register"] + pub wutr: WUTR, + #[doc = "0x18 - calibration register"] + pub calibr: CALIBR, + #[doc = "0x1c - alarm A register"] + pub alrmar: ALRMAR, + #[doc = "0x20 - alarm B register"] + pub alrmbr: ALRMBR, + #[doc = "0x24 - write protection register"] + pub wpr: WPR, + #[doc = "0x28 - sub second register"] + pub ssr: SSR, + #[doc = "0x2c - shift control register"] + pub shiftr: SHIFTR, + #[doc = "0x30 - time stamp time register"] + pub tstr: TSTR, + #[doc = "0x34 - time stamp date register"] + pub tsdr: TSDR, + #[doc = "0x38 - timestamp sub second register"] + pub tsssr: TSSSR, + #[doc = "0x3c - calibration register"] + pub calr: CALR, + #[doc = "0x40 - tamper and alternate function configuration register"] + pub tafcr: TAFCR, + #[doc = "0x44 - alarm A sub second register"] + pub alrmassr: ALRMASSR, + #[doc = "0x48 - alarm B sub second register"] + pub alrmbssr: ALRMBSSR, + _reserved0: [u8; 4usize], + #[doc = "0x50 - backup register"] + pub bkp0r: BKP0R, + #[doc = "0x54 - backup register"] + pub bkp1r: BKP1R, + #[doc = "0x58 - backup register"] + pub bkp2r: BKP2R, + #[doc = "0x5c - backup register"] + pub bkp3r: BKP3R, + #[doc = "0x60 - backup register"] + pub bkp4r: BKP4R, + #[doc = "0x64 - backup register"] + pub bkp5r: BKP5R, + #[doc = "0x68 - backup register"] + pub bkp6r: BKP6R, + #[doc = "0x6c - backup register"] + pub bkp7r: BKP7R, + #[doc = "0x70 - backup register"] + pub bkp8r: BKP8R, + #[doc = "0x74 - backup register"] + pub bkp9r: BKP9R, + #[doc = "0x78 - backup register"] + pub bkp10r: BKP10R, + #[doc = "0x7c - backup register"] + pub bkp11r: BKP11R, + #[doc = "0x80 - backup register"] + pub bkp12r: BKP12R, + #[doc = "0x84 - backup register"] + pub bkp13r: BKP13R, + #[doc = "0x88 - backup register"] + pub bkp14r: BKP14R, + #[doc = "0x8c - backup register"] + pub bkp15r: BKP15R, + #[doc = "0x90 - backup register"] + pub bkp16r: BKP16R, + #[doc = "0x94 - backup register"] + pub bkp17r: BKP17R, + #[doc = "0x98 - backup register"] + pub bkp18r: BKP18R, + #[doc = "0x9c - backup register"] + pub bkp19r: BKP19R, +} +#[doc = "time register"] +pub struct TR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "time register"] +pub mod tr; +#[doc = "date register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "date register"] +pub mod dr; +#[doc = "control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register"] +pub mod cr; +#[doc = "initialization and status register"] +pub struct ISR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "initialization and status register"] +pub mod isr; +#[doc = "prescaler register"] +pub struct PRER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler register"] +pub mod prer; +#[doc = "wakeup timer register"] +pub struct WUTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "wakeup timer register"] +pub mod wutr; +#[doc = "calibration register"] +pub struct CALIBR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "calibration register"] +pub mod calibr; +#[doc = "alarm A register"] +pub struct ALRMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "alarm A register"] +pub mod alrmar; +#[doc = "alarm B register"] +pub struct ALRMBR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "alarm B register"] +pub mod alrmbr; +#[doc = "write protection register"] +pub struct WPR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "write protection register"] +pub mod wpr; +#[doc = "sub second register"] +pub struct SSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "sub second register"] +pub mod ssr; +#[doc = "shift control register"] +pub struct SHIFTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "shift control register"] +pub mod shiftr; +#[doc = "time stamp time register"] +pub struct TSTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "time stamp time register"] +pub mod tstr; +#[doc = "time stamp date register"] +pub struct TSDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "time stamp date register"] +pub mod tsdr; +#[doc = "timestamp sub second register"] +pub struct TSSSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "timestamp sub second register"] +pub mod tsssr; +#[doc = "calibration register"] +pub struct CALR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "calibration register"] +pub mod calr; +#[doc = "tamper and alternate function configuration register"] +pub struct TAFCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "tamper and alternate function configuration register"] +pub mod tafcr; +#[doc = "alarm A sub second register"] +pub struct ALRMASSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "alarm A sub second register"] +pub mod alrmassr; +#[doc = "alarm B sub second register"] +pub struct ALRMBSSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "alarm B sub second register"] +pub mod alrmbssr; +#[doc = "backup register"] +pub struct BKP0R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp0r; +#[doc = "backup register"] +pub struct BKP1R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp1r; +#[doc = "backup register"] +pub struct BKP2R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp2r; +#[doc = "backup register"] +pub struct BKP3R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp3r; +#[doc = "backup register"] +pub struct BKP4R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp4r; +#[doc = "backup register"] +pub struct BKP5R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp5r; +#[doc = "backup register"] +pub struct BKP6R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp6r; +#[doc = "backup register"] +pub struct BKP7R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp7r; +#[doc = "backup register"] +pub struct BKP8R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp8r; +#[doc = "backup register"] +pub struct BKP9R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp9r; +#[doc = "backup register"] +pub struct BKP10R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp10r; +#[doc = "backup register"] +pub struct BKP11R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp11r; +#[doc = "backup register"] +pub struct BKP12R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp12r; +#[doc = "backup register"] +pub struct BKP13R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp13r; +#[doc = "backup register"] +pub struct BKP14R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp14r; +#[doc = "backup register"] +pub struct BKP15R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp15r; +#[doc = "backup register"] +pub struct BKP16R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp16r; +#[doc = "backup register"] +pub struct BKP17R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp17r; +#[doc = "backup register"] +pub struct BKP18R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp18r; +#[doc = "backup register"] +pub struct BKP19R { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "backup register"] +pub mod bkp19r; diff --git a/src/rtc/prer/mod.rs b/src/rtc/prer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a121a72207ea4adc5b368b57dcd4577db64df027 --- /dev/null +++ b/src/rtc/prer/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PRER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PREDIV_AR { + bits: u8, +} +impl PREDIV_AR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PREDIV_SR { + bits: u16, +} +impl PREDIV_SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PREDIV_AW<'a> { + w: &'a mut W, +} +impl<'a> _PREDIV_AW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PREDIV_SW<'a> { + w: &'a mut W, +} +impl<'a> _PREDIV_SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:22 - Asynchronous prescaler factor"] + #[inline] + pub fn prediv_a(&self) -> PREDIV_AR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PREDIV_AR { bits } + } + #[doc = "Bits 0:14 - Synchronous prescaler factor"] + #[inline] + pub fn prediv_s(&self) -> PREDIV_SR { + let bits = { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PREDIV_SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 8323327 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:22 - Asynchronous prescaler factor"] + #[inline] + pub fn prediv_a(&mut self) -> _PREDIV_AW { + _PREDIV_AW { w: self } + } + #[doc = "Bits 0:14 - Synchronous prescaler factor"] + #[inline] + pub fn prediv_s(&mut self) -> _PREDIV_SW { + _PREDIV_SW { w: self } + } +} diff --git a/src/rtc/shiftr/mod.rs b/src/rtc/shiftr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e94c8ffc64d2f562189412b3d60d6aacef7dce32 --- /dev/null +++ b/src/rtc/shiftr/mod.rs @@ -0,0 +1,77 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SHIFTR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _ADD1SW<'a> { + w: &'a mut W, +} +impl<'a> _ADD1SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 31; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SUBFSW<'a> { + w: &'a mut W, +} +impl<'a> _SUBFSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 32767; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 31 - Add one second"] + #[inline] + pub fn add1s(&mut self) -> _ADD1SW { + _ADD1SW { w: self } + } + #[doc = "Bits 0:14 - Subtract a fraction of a second"] + #[inline] + pub fn subfs(&mut self) -> _SUBFSW { + _SUBFSW { w: self } + } +} diff --git a/src/rtc/ssr/mod.rs b/src/rtc/ssr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cb5d48a880ff4c0e3b553518d37117975b67af2e --- /dev/null +++ b/src/rtc/ssr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::SSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SSR { + bits: u16, +} +impl SSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Sub second value"] + #[inline] + pub fn ss(&self) -> SSR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SSR { bits } + } +} diff --git a/src/rtc/tafcr/mod.rs b/src/rtc/tafcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..38fb2d2b89b66926493c31f78f46d6211ed49997 --- /dev/null +++ b/src/rtc/tafcr/mod.rs @@ -0,0 +1,777 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TAFCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ALARMOUTTYPER { + bits: bool, +} +impl ALARMOUTTYPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSINSELR { + bits: bool, +} +impl TSINSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP1INSELR { + bits: bool, +} +impl TAMP1INSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMPPUDISR { + bits: bool, +} +impl TAMPPUDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMPPRCHR { + bits: u8, +} +impl TAMPPRCHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TAMPFLTR { + bits: u8, +} +impl TAMPFLTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TAMPFREQR { + bits: u8, +} +impl TAMPFREQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct TAMPTSR { + bits: bool, +} +impl TAMPTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP2TRGR { + bits: bool, +} +impl TAMP2TRGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP2ER { + bits: bool, +} +impl TAMP2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMPIER { + bits: bool, +} +impl TAMPIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP1TRGR { + bits: bool, +} +impl TAMP1TRGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TAMP1ER { + bits: bool, +} +impl TAMP1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ALARMOUTTYPEW<'a> { + w: &'a mut W, +} +impl<'a> _ALARMOUTTYPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSINSELW<'a> { + w: &'a mut W, +} +impl<'a> _TSINSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP1INSELW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP1INSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPPUDISW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPPUDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPPRCHW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPPRCHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPFLTW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPFLTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPFREQW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPFREQW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPTSW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPTSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP2TRGW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP2TRGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP2EW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMPIEW<'a> { + w: &'a mut W, +} +impl<'a> _TAMPIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP1TRGW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP1TRGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TAMP1EW<'a> { + w: &'a mut W, +} +impl<'a> _TAMP1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 18 - AFO_ALARM output type"] + #[inline] + pub fn alarmouttype(&self) -> ALARMOUTTYPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ALARMOUTTYPER { bits } + } + #[doc = "Bit 17 - TIMESTAMP mapping"] + #[inline] + pub fn tsinsel(&self) -> TSINSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TSINSELR { bits } + } + #[doc = "Bit 16 - TAMPER1 mapping"] + #[inline] + pub fn tamp1insel(&self) -> TAMP1INSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP1INSELR { bits } + } + #[doc = "Bit 15 - TAMPER pull-up disable"] + #[inline] + pub fn tamppudis(&self) -> TAMPPUDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMPPUDISR { bits } + } + #[doc = "Bits 13:14 - Tamper precharge duration"] + #[inline] + pub fn tampprch(&self) -> TAMPPRCHR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TAMPPRCHR { bits } + } + #[doc = "Bits 11:12 - Tamper filter count"] + #[inline] + pub fn tampflt(&self) -> TAMPFLTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TAMPFLTR { bits } + } + #[doc = "Bits 8:10 - Tamper sampling frequency"] + #[inline] + pub fn tampfreq(&self) -> TAMPFREQR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TAMPFREQR { bits } + } + #[doc = "Bit 7 - Activate timestamp on tamper detection event"] + #[inline] + pub fn tampts(&self) -> TAMPTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMPTSR { bits } + } + #[doc = "Bit 4 - Active level for tamper 2"] + #[inline] + pub fn tamp2trg(&self) -> TAMP2TRGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP2TRGR { bits } + } + #[doc = "Bit 3 - Tamper 2 detection enable"] + #[inline] + pub fn tamp2e(&self) -> TAMP2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP2ER { bits } + } + #[doc = "Bit 2 - Tamper interrupt enable"] + #[inline] + pub fn tampie(&self) -> TAMPIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMPIER { bits } + } + #[doc = "Bit 1 - Active level for tamper 1"] + #[inline] + pub fn tamp1trg(&self) -> TAMP1TRGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP1TRGR { bits } + } + #[doc = "Bit 0 - Tamper 1 detection enable"] + #[inline] + pub fn tamp1e(&self) -> TAMP1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TAMP1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 18 - AFO_ALARM output type"] + #[inline] + pub fn alarmouttype(&mut self) -> _ALARMOUTTYPEW { + _ALARMOUTTYPEW { w: self } + } + #[doc = "Bit 17 - TIMESTAMP mapping"] + #[inline] + pub fn tsinsel(&mut self) -> _TSINSELW { + _TSINSELW { w: self } + } + #[doc = "Bit 16 - TAMPER1 mapping"] + #[inline] + pub fn tamp1insel(&mut self) -> _TAMP1INSELW { + _TAMP1INSELW { w: self } + } + #[doc = "Bit 15 - TAMPER pull-up disable"] + #[inline] + pub fn tamppudis(&mut self) -> _TAMPPUDISW { + _TAMPPUDISW { w: self } + } + #[doc = "Bits 13:14 - Tamper precharge duration"] + #[inline] + pub fn tampprch(&mut self) -> _TAMPPRCHW { + _TAMPPRCHW { w: self } + } + #[doc = "Bits 11:12 - Tamper filter count"] + #[inline] + pub fn tampflt(&mut self) -> _TAMPFLTW { + _TAMPFLTW { w: self } + } + #[doc = "Bits 8:10 - Tamper sampling frequency"] + #[inline] + pub fn tampfreq(&mut self) -> _TAMPFREQW { + _TAMPFREQW { w: self } + } + #[doc = "Bit 7 - Activate timestamp on tamper detection event"] + #[inline] + pub fn tampts(&mut self) -> _TAMPTSW { + _TAMPTSW { w: self } + } + #[doc = "Bit 4 - Active level for tamper 2"] + #[inline] + pub fn tamp2trg(&mut self) -> _TAMP2TRGW { + _TAMP2TRGW { w: self } + } + #[doc = "Bit 3 - Tamper 2 detection enable"] + #[inline] + pub fn tamp2e(&mut self) -> _TAMP2EW { + _TAMP2EW { w: self } + } + #[doc = "Bit 2 - Tamper interrupt enable"] + #[inline] + pub fn tampie(&mut self) -> _TAMPIEW { + _TAMPIEW { w: self } + } + #[doc = "Bit 1 - Active level for tamper 1"] + #[inline] + pub fn tamp1trg(&mut self) -> _TAMP1TRGW { + _TAMP1TRGW { w: self } + } + #[doc = "Bit 0 - Tamper 1 detection enable"] + #[inline] + pub fn tamp1e(&mut self) -> _TAMP1EW { + _TAMP1EW { w: self } + } +} diff --git a/src/rtc/tr/mod.rs b/src/rtc/tr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e5fb980f0595e80286bce445f51f0517a660f3e5 --- /dev/null +++ b/src/rtc/tr/mod.rs @@ -0,0 +1,369 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::TR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PMR { + bits: bool, +} +impl PMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTR { + bits: u8, +} +impl HTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HUR { + bits: u8, +} +impl HUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNTR { + bits: u8, +} +impl MNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNUR { + bits: u8, +} +impl MNUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STR { + bits: u8, +} +impl STR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SUR { + bits: u8, +} +impl SUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PMW<'a> { + w: &'a mut W, +} +impl<'a> _PMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HTW<'a> { + w: &'a mut W, +} +impl<'a> _HTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HUW<'a> { + w: &'a mut W, +} +impl<'a> _HUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNTW<'a> { + w: &'a mut W, +} +impl<'a> _MNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MNUW<'a> { + w: &'a mut W, +} +impl<'a> _MNUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STW<'a> { + w: &'a mut W, +} +impl<'a> _STW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SUW<'a> { + w: &'a mut W, +} +impl<'a> _SUW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&self) -> PMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PMR { bits } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&self) -> HTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HTR { bits } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&self) -> HUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HUR { bits } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&self) -> MNTR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNTR { bits } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&self) -> MNUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNUR { bits } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&self) -> STR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STR { bits } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&self) -> SUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SUR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&mut self) -> _PMW { + _PMW { w: self } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&mut self) -> _HTW { + _HTW { w: self } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&mut self) -> _HUW { + _HUW { w: self } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&mut self) -> _MNTW { + _MNTW { w: self } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&mut self) -> _MNUW { + _MNUW { w: self } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&mut self) -> _STW { + _STW { w: self } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&mut self) -> _SUW { + _SUW { w: self } + } +} diff --git a/src/rtc/tsdr/mod.rs b/src/rtc/tsdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d985d9956cd01a58bb73f0a9d5eb38c42ae15cb9 --- /dev/null +++ b/src/rtc/tsdr/mod.rs @@ -0,0 +1,135 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::TSDR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct WDUR { + bits: u8, +} +impl WDUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MTR { + bits: bool, +} +impl MTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUR { + bits: u8, +} +impl MUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTR { + bits: u8, +} +impl DTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DUR { + bits: u8, +} +impl DUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 13:15 - Week day units"] + #[inline] + pub fn wdu(&self) -> WDUR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WDUR { bits } + } + #[doc = "Bit 12 - Month tens in BCD format"] + #[inline] + pub fn mt(&self) -> MTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MTR { bits } + } + #[doc = "Bits 8:11 - Month units in BCD format"] + #[inline] + pub fn mu(&self) -> MUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MUR { bits } + } + #[doc = "Bits 4:5 - Date tens in BCD format"] + #[inline] + pub fn dt(&self) -> DTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTR { bits } + } + #[doc = "Bits 0:3 - Date units in BCD format"] + #[inline] + pub fn du(&self) -> DUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DUR { bits } + } +} diff --git a/src/rtc/tsssr/mod.rs b/src/rtc/tsssr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fe87c5e121a89300dc5be6d38ed63b9e73c11c86 --- /dev/null +++ b/src/rtc/tsssr/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::TSSSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct SSR { + bits: u16, +} +impl SSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Sub second value"] + #[inline] + pub fn ss(&self) -> SSR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SSR { bits } + } +} diff --git a/src/rtc/tstr/mod.rs b/src/rtc/tstr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..715d0563309536d3f87b2f316281c6e2b396c1f2 --- /dev/null +++ b/src/rtc/tstr/mod.rs @@ -0,0 +1,177 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::TSTR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct PMR { + bits: bool, +} +impl PMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HTR { + bits: u8, +} +impl HTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct HUR { + bits: u8, +} +impl HUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNTR { + bits: u8, +} +impl MNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MNUR { + bits: u8, +} +impl MNUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct STR { + bits: u8, +} +impl STR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SUR { + bits: u8, +} +impl SUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 22 - AM/PM notation"] + #[inline] + pub fn pm(&self) -> PMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PMR { bits } + } + #[doc = "Bits 20:21 - Hour tens in BCD format"] + #[inline] + pub fn ht(&self) -> HTR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HTR { bits } + } + #[doc = "Bits 16:19 - Hour units in BCD format"] + #[inline] + pub fn hu(&self) -> HUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + HUR { bits } + } + #[doc = "Bits 12:14 - Minute tens in BCD format"] + #[inline] + pub fn mnt(&self) -> MNTR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNTR { bits } + } + #[doc = "Bits 8:11 - Minute units in BCD format"] + #[inline] + pub fn mnu(&self) -> MNUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MNUR { bits } + } + #[doc = "Bits 4:6 - Second tens in BCD format"] + #[inline] + pub fn st(&self) -> STR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STR { bits } + } + #[doc = "Bits 0:3 - Second units in BCD format"] + #[inline] + pub fn su(&self) -> SUR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SUR { bits } + } +} diff --git a/src/rtc/wpr/mod.rs b/src/rtc/wpr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8d138e179e60c3f8ffb7770084ae70356c6da58 --- /dev/null +++ b/src/rtc/wpr/mod.rs @@ -0,0 +1,49 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::WPR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _KEYW<'a> { + w: &'a mut W, +} +impl<'a> _KEYW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Write protection key"] + #[inline] + pub fn key(&mut self) -> _KEYW { + _KEYW { w: self } + } +} diff --git a/src/rtc/wutr/mod.rs b/src/rtc/wutr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b3d83012ce4d85e380768c6c6f11722bdd0c9aaa --- /dev/null +++ b/src/rtc/wutr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::WUTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WUTR { + bits: u16, +} +impl WUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WUTW<'a> { + w: &'a mut W, +} +impl<'a> _WUTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Wakeup auto-reload value bits"] + #[inline] + pub fn wut(&self) -> WUTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + WUTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 65535 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Wakeup auto-reload value bits"] + #[inline] + pub fn wut(&mut self) -> _WUTW { + _WUTW { w: self } + } +} diff --git a/src/sai/aclrfr/mod.rs b/src/sai/aclrfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0028577d5ab7884184372f450619c5cac3967791 --- /dev/null +++ b/src/sai/aclrfr/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ACLRFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LFSDETR { + bits: bool, +} +impl LFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CAFSDETR { + bits: bool, +} +impl CAFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CNRDYR { + bits: bool, +} +impl CNRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKCFGR { + bits: bool, +} +impl WCKCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTEDETR { + bits: bool, +} +impl MUTEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRUDRR { + bits: bool, +} +impl OVRUDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _LFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _CAFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNRDYW<'a> { + w: &'a mut W, +} +impl<'a> _CNRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WCKCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEDETW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRUDRW<'a> { + w: &'a mut W, +} +impl<'a> _OVRUDRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Clear late frame synchronization detection flag"] + #[inline] + pub fn lfsdet(&self) -> LFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LFSDETR { bits } + } + #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag."] + #[inline] + pub fn cafsdet(&self) -> CAFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CAFSDETR { bits } + } + #[doc = "Bit 4 - Clear codec not ready flag"] + #[inline] + pub fn cnrdy(&self) -> CNRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNRDYR { bits } + } + #[doc = "Bit 2 - Clear wrong clock configuration flag"] + #[inline] + pub fn wckcfg(&self) -> WCKCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WCKCFGR { bits } + } + #[doc = "Bit 1 - Mute detection flag"] + #[inline] + pub fn mutedet(&self) -> MUTEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEDETR { bits } + } + #[doc = "Bit 0 - Clear overrun / underrun"] + #[inline] + pub fn ovrudr(&self) -> OVRUDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRUDRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Clear late frame synchronization detection flag"] + #[inline] + pub fn lfsdet(&mut self) -> _LFSDETW { + _LFSDETW { w: self } + } + #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag."] + #[inline] + pub fn cafsdet(&mut self) -> _CAFSDETW { + _CAFSDETW { w: self } + } + #[doc = "Bit 4 - Clear codec not ready flag"] + #[inline] + pub fn cnrdy(&mut self) -> _CNRDYW { + _CNRDYW { w: self } + } + #[doc = "Bit 2 - Clear wrong clock configuration flag"] + #[inline] + pub fn wckcfg(&mut self) -> _WCKCFGW { + _WCKCFGW { w: self } + } + #[doc = "Bit 1 - Mute detection flag"] + #[inline] + pub fn mutedet(&mut self) -> _MUTEDETW { + _MUTEDETW { w: self } + } + #[doc = "Bit 0 - Clear overrun / underrun"] + #[inline] + pub fn ovrudr(&mut self) -> _OVRUDRW { + _OVRUDRW { w: self } + } +} diff --git a/src/sai/acr1/mod.rs b/src/sai/acr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..81db58d8a56a0dcb4b5da16f6c0800cce668afd8 --- /dev/null +++ b/src/sai/acr1/mod.rs @@ -0,0 +1,682 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ACR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCJDIVR { + bits: u8, +} +impl MCJDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NODIVR { + bits: bool, +} +impl NODIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAENR { + bits: bool, +} +impl DMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAIAENR { + bits: bool, +} +impl SAIAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OUTDRIR { + bits: bool, +} +impl OUTDRIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MONOR { + bits: bool, +} +impl MONOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SYNCENR { + bits: u8, +} +impl SYNCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKSTRR { + bits: bool, +} +impl CKSTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSBFIRSTR { + bits: bool, +} +impl LSBFIRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DSR { + bits: u8, +} +impl DSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PRTCFGR { + bits: u8, +} +impl PRTCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER { + bits: u8, +} +impl MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCJDIVW<'a> { + w: &'a mut W, +} +impl<'a> _MCJDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NODIVW<'a> { + w: &'a mut W, +} +impl<'a> _NODIVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SAIAENW<'a> { + w: &'a mut W, +} +impl<'a> _SAIAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OUTDRIW<'a> { + w: &'a mut W, +} +impl<'a> _OUTDRIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MONOW<'a> { + w: &'a mut W, +} +impl<'a> _MONOW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SYNCENW<'a> { + w: &'a mut W, +} +impl<'a> _SYNCENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKSTRW<'a> { + w: &'a mut W, +} +impl<'a> _CKSTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSBFIRSTW<'a> { + w: &'a mut W, +} +impl<'a> _LSBFIRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DSW<'a> { + w: &'a mut W, +} +impl<'a> _DSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRTCFGW<'a> { + w: &'a mut W, +} +impl<'a> _PRTCFGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODEW<'a> { + w: &'a mut W, +} +impl<'a> _MODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:23 - Master clock divider"] + #[inline] + pub fn mcjdiv(&self) -> MCJDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCJDIVR { bits } + } + #[doc = "Bit 19 - No divider"] + #[inline] + pub fn nodiv(&self) -> NODIVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NODIVR { bits } + } + #[doc = "Bit 17 - DMA enable"] + #[inline] + pub fn dmaen(&self) -> DMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAENR { bits } + } + #[doc = "Bit 16 - Audio block A enable"] + #[inline] + pub fn saiaen(&self) -> SAIAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAIAENR { bits } + } + #[doc = "Bit 13 - Output drive"] + #[inline] + pub fn out_dri(&self) -> OUTDRIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OUTDRIR { bits } + } + #[doc = "Bit 12 - Mono mode"] + #[inline] + pub fn mono(&self) -> MONOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MONOR { bits } + } + #[doc = "Bits 10:11 - Synchronization enable"] + #[inline] + pub fn syncen(&self) -> SYNCENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SYNCENR { bits } + } + #[doc = "Bit 9 - Clock strobing edge"] + #[inline] + pub fn ckstr(&self) -> CKSTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKSTRR { bits } + } + #[doc = "Bit 8 - Least significant bit first"] + #[inline] + pub fn lsbfirst(&self) -> LSBFIRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSBFIRSTR { bits } + } + #[doc = "Bits 5:7 - Data size"] + #[inline] + pub fn ds(&self) -> DSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DSR { bits } + } + #[doc = "Bits 2:3 - Protocol configuration"] + #[inline] + pub fn prtcfg(&self) -> PRTCFGR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRTCFGR { bits } + } + #[doc = "Bits 0:1 - Audio block mode"] + #[inline] + pub fn mode(&self) -> MODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 64 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:23 - Master clock divider"] + #[inline] + pub fn mcjdiv(&mut self) -> _MCJDIVW { + _MCJDIVW { w: self } + } + #[doc = "Bit 19 - No divider"] + #[inline] + pub fn nodiv(&mut self) -> _NODIVW { + _NODIVW { w: self } + } + #[doc = "Bit 17 - DMA enable"] + #[inline] + pub fn dmaen(&mut self) -> _DMAENW { + _DMAENW { w: self } + } + #[doc = "Bit 16 - Audio block A enable"] + #[inline] + pub fn saiaen(&mut self) -> _SAIAENW { + _SAIAENW { w: self } + } + #[doc = "Bit 13 - Output drive"] + #[inline] + pub fn out_dri(&mut self) -> _OUTDRIW { + _OUTDRIW { w: self } + } + #[doc = "Bit 12 - Mono mode"] + #[inline] + pub fn mono(&mut self) -> _MONOW { + _MONOW { w: self } + } + #[doc = "Bits 10:11 - Synchronization enable"] + #[inline] + pub fn syncen(&mut self) -> _SYNCENW { + _SYNCENW { w: self } + } + #[doc = "Bit 9 - Clock strobing edge"] + #[inline] + pub fn ckstr(&mut self) -> _CKSTRW { + _CKSTRW { w: self } + } + #[doc = "Bit 8 - Least significant bit first"] + #[inline] + pub fn lsbfirst(&mut self) -> _LSBFIRSTW { + _LSBFIRSTW { w: self } + } + #[doc = "Bits 5:7 - Data size"] + #[inline] + pub fn ds(&mut self) -> _DSW { + _DSW { w: self } + } + #[doc = "Bits 2:3 - Protocol configuration"] + #[inline] + pub fn prtcfg(&mut self) -> _PRTCFGW { + _PRTCFGW { w: self } + } + #[doc = "Bits 0:1 - Audio block mode"] + #[inline] + pub fn mode(&mut self) -> _MODEW { + _MODEW { w: self } + } +} diff --git a/src/sai/acr2/mod.rs b/src/sai/acr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e08cffa66ea0dde735d6af388a8cf27b28ae323d --- /dev/null +++ b/src/sai/acr2/mod.rs @@ -0,0 +1,482 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ACR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct COMPR { + bits: u8, +} +impl COMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CPLR { + bits: bool, +} +impl CPLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTECNR { + bits: u8, +} +impl MUTECNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUTEVALR { + bits: bool, +} +impl MUTEVALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTER { + bits: bool, +} +impl MUTER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRISR { + bits: bool, +} +impl TRISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFLUSR { + bits: bool, +} +impl FFLUSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _COMPW<'a> { + w: &'a mut W, +} +impl<'a> _COMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPLW<'a> { + w: &'a mut W, +} +impl<'a> _CPLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTECNW<'a> { + w: &'a mut W, +} +impl<'a> _MUTECNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEVALW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEVALW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRISW<'a> { + w: &'a mut W, +} +impl<'a> _TRISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFLUSW<'a> { + w: &'a mut W, +} +impl<'a> _FFLUSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - Companding mode"] + #[inline] + pub fn comp(&self) -> COMPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + COMPR { bits } + } + #[doc = "Bit 13 - Complement bit"] + #[inline] + pub fn cpl(&self) -> CPLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPLR { bits } + } + #[doc = "Bits 7:12 - Mute counter"] + #[inline] + pub fn mutecn(&self) -> MUTECNR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MUTECNR { bits } + } + #[doc = "Bit 6 - Mute value"] + #[inline] + pub fn muteval(&self) -> MUTEVALR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEVALR { bits } + } + #[doc = "Bit 5 - Mute"] + #[inline] + pub fn mute(&self) -> MUTER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTER { bits } + } + #[doc = "Bit 4 - Tristate management on data line"] + #[inline] + pub fn tris(&self) -> TRISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TRISR { bits } + } + #[doc = "Bit 3 - FIFO flush"] + #[inline] + pub fn fflus(&self) -> FFLUSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFLUSR { bits } + } + #[doc = "Bits 0:2 - FIFO threshold"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - Companding mode"] + #[inline] + pub fn comp(&mut self) -> _COMPW { + _COMPW { w: self } + } + #[doc = "Bit 13 - Complement bit"] + #[inline] + pub fn cpl(&mut self) -> _CPLW { + _CPLW { w: self } + } + #[doc = "Bits 7:12 - Mute counter"] + #[inline] + pub fn mutecn(&mut self) -> _MUTECNW { + _MUTECNW { w: self } + } + #[doc = "Bit 6 - Mute value"] + #[inline] + pub fn muteval(&mut self) -> _MUTEVALW { + _MUTEVALW { w: self } + } + #[doc = "Bit 5 - Mute"] + #[inline] + pub fn mute(&mut self) -> _MUTEW { + _MUTEW { w: self } + } + #[doc = "Bit 4 - Tristate management on data line"] + #[inline] + pub fn tris(&mut self) -> _TRISW { + _TRISW { w: self } + } + #[doc = "Bit 3 - FIFO flush"] + #[inline] + pub fn fflus(&mut self) -> _FFLUSW { + _FFLUSW { w: self } + } + #[doc = "Bits 0:2 - FIFO threshold"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/sai/adr/mod.rs b/src/sai/adr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..097dad26d0d1808cae9fe14ca756a2ae2b9e0605 --- /dev/null +++ b/src/sai/adr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ADR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATAR { + bits: u32, +} +impl DATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATAW<'a> { + w: &'a mut W, +} +impl<'a> _DATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&self) -> DATAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&mut self) -> _DATAW { + _DATAW { w: self } + } +} diff --git a/src/sai/afrcr/mod.rs b/src/sai/afrcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..07394e8c304f677f9d90852cbb2fb664978d96f2 --- /dev/null +++ b/src/sai/afrcr/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AFRCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSOFFR { + bits: bool, +} +impl FSOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSPOLR { + bits: bool, +} +impl FSPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSDEFR { + bits: bool, +} +impl FSDEFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSALLR { + bits: u8, +} +impl FSALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FRLR { + bits: u8, +} +impl FRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FSOFFW<'a> { + w: &'a mut W, +} +impl<'a> _FSOFFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSPOLW<'a> { + w: &'a mut W, +} +impl<'a> _FSPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSDEFW<'a> { + w: &'a mut W, +} +impl<'a> _FSDEFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSALLW<'a> { + w: &'a mut W, +} +impl<'a> _FSALLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRLW<'a> { + w: &'a mut W, +} +impl<'a> _FRLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 18 - Frame synchronization offset"] + #[inline] + pub fn fsoff(&self) -> FSOFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSOFFR { bits } + } + #[doc = "Bit 17 - Frame synchronization polarity"] + #[inline] + pub fn fspol(&self) -> FSPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSPOLR { bits } + } + #[doc = "Bit 16 - Frame synchronization definition"] + #[inline] + pub fn fsdef(&self) -> FSDEFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSDEFR { bits } + } + #[doc = "Bits 8:14 - Frame synchronization active level length"] + #[inline] + pub fn fsall(&self) -> FSALLR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSALLR { bits } + } + #[doc = "Bits 0:7 - Frame length"] + #[inline] + pub fn frl(&self) -> FRLR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FRLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 7 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 18 - Frame synchronization offset"] + #[inline] + pub fn fsoff(&mut self) -> _FSOFFW { + _FSOFFW { w: self } + } + #[doc = "Bit 17 - Frame synchronization polarity"] + #[inline] + pub fn fspol(&mut self) -> _FSPOLW { + _FSPOLW { w: self } + } + #[doc = "Bit 16 - Frame synchronization definition"] + #[inline] + pub fn fsdef(&mut self) -> _FSDEFW { + _FSDEFW { w: self } + } + #[doc = "Bits 8:14 - Frame synchronization active level length"] + #[inline] + pub fn fsall(&mut self) -> _FSALLW { + _FSALLW { w: self } + } + #[doc = "Bits 0:7 - Frame length"] + #[inline] + pub fn frl(&mut self) -> _FRLW { + _FRLW { w: self } + } +} diff --git a/src/sai/aim/mod.rs b/src/sai/aim/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8e187d82ff858aadae3d55f73906ec2784bd15b4 --- /dev/null +++ b/src/sai/aim/mod.rs @@ -0,0 +1,477 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::AIM { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LFSDETR { + bits: bool, +} +impl LFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AFSDETIER { + bits: bool, +} +impl AFSDETIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CNRDYIER { + bits: bool, +} +impl CNRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FREQIER { + bits: bool, +} +impl FREQIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKCFGR { + bits: bool, +} +impl WCKCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTEDETR { + bits: bool, +} +impl MUTEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRUDRIER { + bits: bool, +} +impl OVRUDRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _LFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFSDETIEW<'a> { + w: &'a mut W, +} +impl<'a> _AFSDETIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _CNRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FREQIEW<'a> { + w: &'a mut W, +} +impl<'a> _FREQIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WCKCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEDETW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRUDRIEW<'a> { + w: &'a mut W, +} +impl<'a> _OVRUDRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"] + #[inline] + pub fn lfsdet(&self) -> LFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LFSDETR { bits } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"] + #[inline] + pub fn afsdetie(&self) -> AFSDETIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AFSDETIER { bits } + } + #[doc = "Bit 4 - Codec not ready interrupt enable"] + #[inline] + pub fn cnrdyie(&self) -> CNRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNRDYIER { bits } + } + #[doc = "Bit 3 - FIFO request interrupt enable"] + #[inline] + pub fn freqie(&self) -> FREQIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FREQIER { bits } + } + #[doc = "Bit 2 - Wrong clock configuration interrupt enable"] + #[inline] + pub fn wckcfg(&self) -> WCKCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WCKCFGR { bits } + } + #[doc = "Bit 1 - Mute detection interrupt enable"] + #[inline] + pub fn mutedet(&self) -> MUTEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEDETR { bits } + } + #[doc = "Bit 0 - Overrun/underrun interrupt enable"] + #[inline] + pub fn ovrudrie(&self) -> OVRUDRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRUDRIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"] + #[inline] + pub fn lfsdet(&mut self) -> _LFSDETW { + _LFSDETW { w: self } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"] + #[inline] + pub fn afsdetie(&mut self) -> _AFSDETIEW { + _AFSDETIEW { w: self } + } + #[doc = "Bit 4 - Codec not ready interrupt enable"] + #[inline] + pub fn cnrdyie(&mut self) -> _CNRDYIEW { + _CNRDYIEW { w: self } + } + #[doc = "Bit 3 - FIFO request interrupt enable"] + #[inline] + pub fn freqie(&mut self) -> _FREQIEW { + _FREQIEW { w: self } + } + #[doc = "Bit 2 - Wrong clock configuration interrupt enable"] + #[inline] + pub fn wckcfg(&mut self) -> _WCKCFGW { + _WCKCFGW { w: self } + } + #[doc = "Bit 1 - Mute detection interrupt enable"] + #[inline] + pub fn mutedet(&mut self) -> _MUTEDETW { + _MUTEDETW { w: self } + } + #[doc = "Bit 0 - Overrun/underrun interrupt enable"] + #[inline] + pub fn ovrudrie(&mut self) -> _OVRUDRIEW { + _OVRUDRIEW { w: self } + } +} diff --git a/src/sai/aslotr/mod.rs b/src/sai/aslotr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4d36f8eb22e54498dd3842a50d226376fbdd750c --- /dev/null +++ b/src/sai/aslotr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ASLOTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SLOTENR { + bits: u16, +} +impl SLOTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NBSLOTR { + bits: u8, +} +impl NBSLOTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SLOTSZR { + bits: u8, +} +impl SLOTSZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FBOFFR { + bits: u8, +} +impl FBOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SLOTENW<'a> { + w: &'a mut W, +} +impl<'a> _SLOTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NBSLOTW<'a> { + w: &'a mut W, +} +impl<'a> _NBSLOTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SLOTSZW<'a> { + w: &'a mut W, +} +impl<'a> _SLOTSZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBOFFW<'a> { + w: &'a mut W, +} +impl<'a> _FBOFFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - Slot enable"] + #[inline] + pub fn sloten(&self) -> SLOTENR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SLOTENR { bits } + } + #[doc = "Bits 8:11 - Number of slots in an audio frame"] + #[inline] + pub fn nbslot(&self) -> NBSLOTR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + NBSLOTR { bits } + } + #[doc = "Bits 6:7 - Slot size"] + #[inline] + pub fn slotsz(&self) -> SLOTSZR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SLOTSZR { bits } + } + #[doc = "Bits 0:4 - First bit offset"] + #[inline] + pub fn fboff(&self) -> FBOFFR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FBOFFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - Slot enable"] + #[inline] + pub fn sloten(&mut self) -> _SLOTENW { + _SLOTENW { w: self } + } + #[doc = "Bits 8:11 - Number of slots in an audio frame"] + #[inline] + pub fn nbslot(&mut self) -> _NBSLOTW { + _NBSLOTW { w: self } + } + #[doc = "Bits 6:7 - Slot size"] + #[inline] + pub fn slotsz(&mut self) -> _SLOTSZW { + _SLOTSZW { w: self } + } + #[doc = "Bits 0:4 - First bit offset"] + #[inline] + pub fn fboff(&mut self) -> _FBOFFW { + _FBOFFW { w: self } + } +} diff --git a/src/sai/asr/mod.rs b/src/sai/asr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7255e0d48d8fce768cffda730b9d5571bb9bf390 --- /dev/null +++ b/src/sai/asr/mod.rs @@ -0,0 +1,518 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ASR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FLVLR { + bits: u8, +} +impl FLVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct LFSDETR { + bits: bool, +} +impl LFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AFSDETR { + bits: bool, +} +impl AFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CNRDYR { + bits: bool, +} +impl CNRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FREQR { + bits: bool, +} +impl FREQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKCFGR { + bits: bool, +} +impl WCKCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTEDETR { + bits: bool, +} +impl MUTEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRUDRR { + bits: bool, +} +impl OVRUDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _FLVLW<'a> { + w: &'a mut W, +} +impl<'a> _FLVLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _LFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _AFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNRDYW<'a> { + w: &'a mut W, +} +impl<'a> _CNRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FREQW<'a> { + w: &'a mut W, +} +impl<'a> _FREQW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WCKCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEDETW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRUDRW<'a> { + w: &'a mut W, +} +impl<'a> _OVRUDRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:18 - FIFO level threshold"] + #[inline] + pub fn flvl(&self) -> FLVLR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FLVLR { bits } + } + #[doc = "Bit 6 - Late frame synchronization detection"] + #[inline] + pub fn lfsdet(&self) -> LFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LFSDETR { bits } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection"] + #[inline] + pub fn afsdet(&self) -> AFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AFSDETR { bits } + } + #[doc = "Bit 4 - Codec not ready"] + #[inline] + pub fn cnrdy(&self) -> CNRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNRDYR { bits } + } + #[doc = "Bit 3 - FIFO request"] + #[inline] + pub fn freq(&self) -> FREQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FREQR { bits } + } + #[doc = "Bit 2 - Wrong clock configuration flag. This bit is read only."] + #[inline] + pub fn wckcfg(&self) -> WCKCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WCKCFGR { bits } + } + #[doc = "Bit 1 - Mute detection"] + #[inline] + pub fn mutedet(&self) -> MUTEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEDETR { bits } + } + #[doc = "Bit 0 - Overrun / underrun"] + #[inline] + pub fn ovrudr(&self) -> OVRUDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRUDRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:18 - FIFO level threshold"] + #[inline] + pub fn flvl(&mut self) -> _FLVLW { + _FLVLW { w: self } + } + #[doc = "Bit 6 - Late frame synchronization detection"] + #[inline] + pub fn lfsdet(&mut self) -> _LFSDETW { + _LFSDETW { w: self } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection"] + #[inline] + pub fn afsdet(&mut self) -> _AFSDETW { + _AFSDETW { w: self } + } + #[doc = "Bit 4 - Codec not ready"] + #[inline] + pub fn cnrdy(&mut self) -> _CNRDYW { + _CNRDYW { w: self } + } + #[doc = "Bit 3 - FIFO request"] + #[inline] + pub fn freq(&mut self) -> _FREQW { + _FREQW { w: self } + } + #[doc = "Bit 2 - Wrong clock configuration flag. This bit is read only."] + #[inline] + pub fn wckcfg(&mut self) -> _WCKCFGW { + _WCKCFGW { w: self } + } + #[doc = "Bit 1 - Mute detection"] + #[inline] + pub fn mutedet(&mut self) -> _MUTEDETW { + _MUTEDETW { w: self } + } + #[doc = "Bit 0 - Overrun / underrun"] + #[inline] + pub fn ovrudr(&mut self) -> _OVRUDRW { + _OVRUDRW { w: self } + } +} diff --git a/src/sai/bclrfr/mod.rs b/src/sai/bclrfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..62a5c8182282d09addbb8e5211d935ca1a460b2a --- /dev/null +++ b/src/sai/bclrfr/mod.rs @@ -0,0 +1,197 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCLRFR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _LFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _LFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CAFSDETW<'a> { + w: &'a mut W, +} +impl<'a> _CAFSDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNRDYW<'a> { + w: &'a mut W, +} +impl<'a> _CNRDYW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WCKCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEDETW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRUDRW<'a> { + w: &'a mut W, +} +impl<'a> _OVRUDRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Clear late frame synchronization detection flag"] + #[inline] + pub fn lfsdet(&mut self) -> _LFSDETW { + _LFSDETW { w: self } + } + #[doc = "Bit 5 - Clear anticipated frame synchronization detection flag"] + #[inline] + pub fn cafsdet(&mut self) -> _CAFSDETW { + _CAFSDETW { w: self } + } + #[doc = "Bit 4 - Clear codec not ready flag"] + #[inline] + pub fn cnrdy(&mut self) -> _CNRDYW { + _CNRDYW { w: self } + } + #[doc = "Bit 2 - Clear wrong clock configuration flag"] + #[inline] + pub fn wckcfg(&mut self) -> _WCKCFGW { + _WCKCFGW { w: self } + } + #[doc = "Bit 1 - Mute detection flag"] + #[inline] + pub fn mutedet(&mut self) -> _MUTEDETW { + _MUTEDETW { w: self } + } + #[doc = "Bit 0 - Clear overrun / underrun"] + #[inline] + pub fn ovrudr(&mut self) -> _OVRUDRW { + _OVRUDRW { w: self } + } +} diff --git a/src/sai/bcr1/mod.rs b/src/sai/bcr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..7c1c565425ee7d8ca05f9b80c951571f0b2a41e9 --- /dev/null +++ b/src/sai/bcr1/mod.rs @@ -0,0 +1,682 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MCJDIVR { + bits: u8, +} +impl MCJDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NODIVR { + bits: bool, +} +impl NODIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMAENR { + bits: bool, +} +impl DMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SAIBENR { + bits: bool, +} +impl SAIBENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OUTDRIR { + bits: bool, +} +impl OUTDRIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MONOR { + bits: bool, +} +impl MONOR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SYNCENR { + bits: u8, +} +impl SYNCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CKSTRR { + bits: bool, +} +impl CKSTRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LSBFIRSTR { + bits: bool, +} +impl LSBFIRSTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DSR { + bits: u8, +} +impl DSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PRTCFGR { + bits: u8, +} +impl PRTCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MODER { + bits: u8, +} +impl MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MCJDIVW<'a> { + w: &'a mut W, +} +impl<'a> _MCJDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NODIVW<'a> { + w: &'a mut W, +} +impl<'a> _NODIVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SAIBENW<'a> { + w: &'a mut W, +} +impl<'a> _SAIBENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OUTDRIW<'a> { + w: &'a mut W, +} +impl<'a> _OUTDRIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MONOW<'a> { + w: &'a mut W, +} +impl<'a> _MONOW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SYNCENW<'a> { + w: &'a mut W, +} +impl<'a> _SYNCENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CKSTRW<'a> { + w: &'a mut W, +} +impl<'a> _CKSTRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LSBFIRSTW<'a> { + w: &'a mut W, +} +impl<'a> _LSBFIRSTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DSW<'a> { + w: &'a mut W, +} +impl<'a> _DSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PRTCFGW<'a> { + w: &'a mut W, +} +impl<'a> _PRTCFGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MODEW<'a> { + w: &'a mut W, +} +impl<'a> _MODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 20:23 - Master clock divider"] + #[inline] + pub fn mcjdiv(&self) -> MCJDIVR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MCJDIVR { bits } + } + #[doc = "Bit 19 - No divider"] + #[inline] + pub fn nodiv(&self) -> NODIVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NODIVR { bits } + } + #[doc = "Bit 17 - DMA enable"] + #[inline] + pub fn dmaen(&self) -> DMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAENR { bits } + } + #[doc = "Bit 16 - Audio block B enable"] + #[inline] + pub fn saiben(&self) -> SAIBENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SAIBENR { bits } + } + #[doc = "Bit 13 - Output drive"] + #[inline] + pub fn out_dri(&self) -> OUTDRIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OUTDRIR { bits } + } + #[doc = "Bit 12 - Mono mode"] + #[inline] + pub fn mono(&self) -> MONOR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MONOR { bits } + } + #[doc = "Bits 10:11 - Synchronization enable"] + #[inline] + pub fn syncen(&self) -> SYNCENR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SYNCENR { bits } + } + #[doc = "Bit 9 - Clock strobing edge"] + #[inline] + pub fn ckstr(&self) -> CKSTRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CKSTRR { bits } + } + #[doc = "Bit 8 - Least significant bit first"] + #[inline] + pub fn lsbfirst(&self) -> LSBFIRSTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LSBFIRSTR { bits } + } + #[doc = "Bits 5:7 - Data size"] + #[inline] + pub fn ds(&self) -> DSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DSR { bits } + } + #[doc = "Bits 2:3 - Protocol configuration"] + #[inline] + pub fn prtcfg(&self) -> PRTCFGR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PRTCFGR { bits } + } + #[doc = "Bits 0:1 - Audio block mode"] + #[inline] + pub fn mode(&self) -> MODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 64 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 20:23 - Master clock divider"] + #[inline] + pub fn mcjdiv(&mut self) -> _MCJDIVW { + _MCJDIVW { w: self } + } + #[doc = "Bit 19 - No divider"] + #[inline] + pub fn nodiv(&mut self) -> _NODIVW { + _NODIVW { w: self } + } + #[doc = "Bit 17 - DMA enable"] + #[inline] + pub fn dmaen(&mut self) -> _DMAENW { + _DMAENW { w: self } + } + #[doc = "Bit 16 - Audio block B enable"] + #[inline] + pub fn saiben(&mut self) -> _SAIBENW { + _SAIBENW { w: self } + } + #[doc = "Bit 13 - Output drive"] + #[inline] + pub fn out_dri(&mut self) -> _OUTDRIW { + _OUTDRIW { w: self } + } + #[doc = "Bit 12 - Mono mode"] + #[inline] + pub fn mono(&mut self) -> _MONOW { + _MONOW { w: self } + } + #[doc = "Bits 10:11 - Synchronization enable"] + #[inline] + pub fn syncen(&mut self) -> _SYNCENW { + _SYNCENW { w: self } + } + #[doc = "Bit 9 - Clock strobing edge"] + #[inline] + pub fn ckstr(&mut self) -> _CKSTRW { + _CKSTRW { w: self } + } + #[doc = "Bit 8 - Least significant bit first"] + #[inline] + pub fn lsbfirst(&mut self) -> _LSBFIRSTW { + _LSBFIRSTW { w: self } + } + #[doc = "Bits 5:7 - Data size"] + #[inline] + pub fn ds(&mut self) -> _DSW { + _DSW { w: self } + } + #[doc = "Bits 2:3 - Protocol configuration"] + #[inline] + pub fn prtcfg(&mut self) -> _PRTCFGW { + _PRTCFGW { w: self } + } + #[doc = "Bits 0:1 - Audio block mode"] + #[inline] + pub fn mode(&mut self) -> _MODEW { + _MODEW { w: self } + } +} diff --git a/src/sai/bcr2/mod.rs b/src/sai/bcr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5f039d0bd4d6ecadd3eec32d814db37cb6dfc72d --- /dev/null +++ b/src/sai/bcr2/mod.rs @@ -0,0 +1,482 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct COMPR { + bits: u8, +} +impl COMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CPLR { + bits: bool, +} +impl CPLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTECNR { + bits: u8, +} +impl MUTECNR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MUTEVALR { + bits: bool, +} +impl MUTEVALR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTER { + bits: bool, +} +impl MUTER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TRISR { + bits: bool, +} +impl TRISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FFLUSR { + bits: bool, +} +impl FFLUSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FTHR { + bits: u8, +} +impl FTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _COMPW<'a> { + w: &'a mut W, +} +impl<'a> _COMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPLW<'a> { + w: &'a mut W, +} +impl<'a> _CPLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTECNW<'a> { + w: &'a mut W, +} +impl<'a> _MUTECNW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEVALW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEVALW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TRISW<'a> { + w: &'a mut W, +} +impl<'a> _TRISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FFLUSW<'a> { + w: &'a mut W, +} +impl<'a> _FFLUSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FTHW<'a> { + w: &'a mut W, +} +impl<'a> _FTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 14:15 - Companding mode"] + #[inline] + pub fn comp(&self) -> COMPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + COMPR { bits } + } + #[doc = "Bit 13 - Complement bit"] + #[inline] + pub fn cpl(&self) -> CPLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPLR { bits } + } + #[doc = "Bits 7:12 - Mute counter"] + #[inline] + pub fn mutecn(&self) -> MUTECNR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MUTECNR { bits } + } + #[doc = "Bit 6 - Mute value"] + #[inline] + pub fn muteval(&self) -> MUTEVALR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEVALR { bits } + } + #[doc = "Bit 5 - Mute"] + #[inline] + pub fn mute(&self) -> MUTER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTER { bits } + } + #[doc = "Bit 4 - Tristate management on data line"] + #[inline] + pub fn tris(&self) -> TRISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TRISR { bits } + } + #[doc = "Bit 3 - FIFO flush"] + #[inline] + pub fn fflus(&self) -> FFLUSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FFLUSR { bits } + } + #[doc = "Bits 0:2 - FIFO threshold"] + #[inline] + pub fn fth(&self) -> FTHR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 14:15 - Companding mode"] + #[inline] + pub fn comp(&mut self) -> _COMPW { + _COMPW { w: self } + } + #[doc = "Bit 13 - Complement bit"] + #[inline] + pub fn cpl(&mut self) -> _CPLW { + _CPLW { w: self } + } + #[doc = "Bits 7:12 - Mute counter"] + #[inline] + pub fn mutecn(&mut self) -> _MUTECNW { + _MUTECNW { w: self } + } + #[doc = "Bit 6 - Mute value"] + #[inline] + pub fn muteval(&mut self) -> _MUTEVALW { + _MUTEVALW { w: self } + } + #[doc = "Bit 5 - Mute"] + #[inline] + pub fn mute(&mut self) -> _MUTEW { + _MUTEW { w: self } + } + #[doc = "Bit 4 - Tristate management on data line"] + #[inline] + pub fn tris(&mut self) -> _TRISW { + _TRISW { w: self } + } + #[doc = "Bit 3 - FIFO flush"] + #[inline] + pub fn fflus(&mut self) -> _FFLUSW { + _FFLUSW { w: self } + } + #[doc = "Bits 0:2 - FIFO threshold"] + #[inline] + pub fn fth(&mut self) -> _FTHW { + _FTHW { w: self } + } +} diff --git a/src/sai/bdr/mod.rs b/src/sai/bdr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d2e500bc8a5985be089cac941e2d4ded5c1d6e70 --- /dev/null +++ b/src/sai/bdr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BDR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATAR { + bits: u32, +} +impl DATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATAW<'a> { + w: &'a mut W, +} +impl<'a> _DATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&self) -> DATAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data"] + #[inline] + pub fn data(&mut self) -> _DATAW { + _DATAW { w: self } + } +} diff --git a/src/sai/bfrcr/mod.rs b/src/sai/bfrcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..24004562136c31924fa3cdfc0cb348a36a2914da --- /dev/null +++ b/src/sai/bfrcr/mod.rs @@ -0,0 +1,323 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BFRCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FSOFFR { + bits: bool, +} +impl FSOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSPOLR { + bits: bool, +} +impl FSPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSDEFR { + bits: bool, +} +impl FSDEFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FSALLR { + bits: u8, +} +impl FSALLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FRLR { + bits: u8, +} +impl FRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FSOFFW<'a> { + w: &'a mut W, +} +impl<'a> _FSOFFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSPOLW<'a> { + w: &'a mut W, +} +impl<'a> _FSPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSDEFW<'a> { + w: &'a mut W, +} +impl<'a> _FSDEFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FSALLW<'a> { + w: &'a mut W, +} +impl<'a> _FSALLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FRLW<'a> { + w: &'a mut W, +} +impl<'a> _FRLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 18 - Frame synchronization offset"] + #[inline] + pub fn fsoff(&self) -> FSOFFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSOFFR { bits } + } + #[doc = "Bit 17 - Frame synchronization polarity"] + #[inline] + pub fn fspol(&self) -> FSPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSPOLR { bits } + } + #[doc = "Bit 16 - Frame synchronization definition"] + #[inline] + pub fn fsdef(&self) -> FSDEFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FSDEFR { bits } + } + #[doc = "Bits 8:14 - Frame synchronization active level length"] + #[inline] + pub fn fsall(&self) -> FSALLR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FSALLR { bits } + } + #[doc = "Bits 0:7 - Frame length"] + #[inline] + pub fn frl(&self) -> FRLR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FRLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 7 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 18 - Frame synchronization offset"] + #[inline] + pub fn fsoff(&mut self) -> _FSOFFW { + _FSOFFW { w: self } + } + #[doc = "Bit 17 - Frame synchronization polarity"] + #[inline] + pub fn fspol(&mut self) -> _FSPOLW { + _FSPOLW { w: self } + } + #[doc = "Bit 16 - Frame synchronization definition"] + #[inline] + pub fn fsdef(&mut self) -> _FSDEFW { + _FSDEFW { w: self } + } + #[doc = "Bits 8:14 - Frame synchronization active level length"] + #[inline] + pub fn fsall(&mut self) -> _FSALLW { + _FSALLW { w: self } + } + #[doc = "Bits 0:7 - Frame length"] + #[inline] + pub fn frl(&mut self) -> _FRLW { + _FRLW { w: self } + } +} diff --git a/src/sai/bim/mod.rs b/src/sai/bim/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3981091faf5367377cf87ab6fe5d9db6ca12f820 --- /dev/null +++ b/src/sai/bim/mod.rs @@ -0,0 +1,477 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BIM { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LFSDETIER { + bits: bool, +} +impl LFSDETIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AFSDETIER { + bits: bool, +} +impl AFSDETIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CNRDYIER { + bits: bool, +} +impl CNRDYIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FREQIER { + bits: bool, +} +impl FREQIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKCFGR { + bits: bool, +} +impl WCKCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTEDETR { + bits: bool, +} +impl MUTEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRUDRIER { + bits: bool, +} +impl OVRUDRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _LFSDETIEW<'a> { + w: &'a mut W, +} +impl<'a> _LFSDETIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AFSDETIEW<'a> { + w: &'a mut W, +} +impl<'a> _AFSDETIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNRDYIEW<'a> { + w: &'a mut W, +} +impl<'a> _CNRDYIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FREQIEW<'a> { + w: &'a mut W, +} +impl<'a> _FREQIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WCKCFGW<'a> { + w: &'a mut W, +} +impl<'a> _WCKCFGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MUTEDETW<'a> { + w: &'a mut W, +} +impl<'a> _MUTEDETW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OVRUDRIEW<'a> { + w: &'a mut W, +} +impl<'a> _OVRUDRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"] + #[inline] + pub fn lfsdetie(&self) -> LFSDETIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LFSDETIER { bits } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"] + #[inline] + pub fn afsdetie(&self) -> AFSDETIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AFSDETIER { bits } + } + #[doc = "Bit 4 - Codec not ready interrupt enable"] + #[inline] + pub fn cnrdyie(&self) -> CNRDYIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNRDYIER { bits } + } + #[doc = "Bit 3 - FIFO request interrupt enable"] + #[inline] + pub fn freqie(&self) -> FREQIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FREQIER { bits } + } + #[doc = "Bit 2 - Wrong clock configuration interrupt enable"] + #[inline] + pub fn wckcfg(&self) -> WCKCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WCKCFGR { bits } + } + #[doc = "Bit 1 - Mute detection interrupt enable"] + #[inline] + pub fn mutedet(&self) -> MUTEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEDETR { bits } + } + #[doc = "Bit 0 - Overrun/underrun interrupt enable"] + #[inline] + pub fn ovrudrie(&self) -> OVRUDRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRUDRIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Late frame synchronization detection interrupt enable"] + #[inline] + pub fn lfsdetie(&mut self) -> _LFSDETIEW { + _LFSDETIEW { w: self } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection interrupt enable"] + #[inline] + pub fn afsdetie(&mut self) -> _AFSDETIEW { + _AFSDETIEW { w: self } + } + #[doc = "Bit 4 - Codec not ready interrupt enable"] + #[inline] + pub fn cnrdyie(&mut self) -> _CNRDYIEW { + _CNRDYIEW { w: self } + } + #[doc = "Bit 3 - FIFO request interrupt enable"] + #[inline] + pub fn freqie(&mut self) -> _FREQIEW { + _FREQIEW { w: self } + } + #[doc = "Bit 2 - Wrong clock configuration interrupt enable"] + #[inline] + pub fn wckcfg(&mut self) -> _WCKCFGW { + _WCKCFGW { w: self } + } + #[doc = "Bit 1 - Mute detection interrupt enable"] + #[inline] + pub fn mutedet(&mut self) -> _MUTEDETW { + _MUTEDETW { w: self } + } + #[doc = "Bit 0 - Overrun/underrun interrupt enable"] + #[inline] + pub fn ovrudrie(&mut self) -> _OVRUDRIEW { + _OVRUDRIEW { w: self } + } +} diff --git a/src/sai/bslotr/mod.rs b/src/sai/bslotr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..edca371ad4f2b85a7528d30884bea616d61f8bc0 --- /dev/null +++ b/src/sai/bslotr/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BSLOTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SLOTENR { + bits: u16, +} +impl SLOTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct NBSLOTR { + bits: u8, +} +impl NBSLOTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SLOTSZR { + bits: u8, +} +impl SLOTSZR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct FBOFFR { + bits: u8, +} +impl FBOFFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _SLOTENW<'a> { + w: &'a mut W, +} +impl<'a> _SLOTENW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NBSLOTW<'a> { + w: &'a mut W, +} +impl<'a> _NBSLOTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SLOTSZW<'a> { + w: &'a mut W, +} +impl<'a> _SLOTSZW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _FBOFFW<'a> { + w: &'a mut W, +} +impl<'a> _FBOFFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - Slot enable"] + #[inline] + pub fn sloten(&self) -> SLOTENR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + SLOTENR { bits } + } + #[doc = "Bits 8:11 - Number of slots in an audio frame"] + #[inline] + pub fn nbslot(&self) -> NBSLOTR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + NBSLOTR { bits } + } + #[doc = "Bits 6:7 - Slot size"] + #[inline] + pub fn slotsz(&self) -> SLOTSZR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SLOTSZR { bits } + } + #[doc = "Bits 0:4 - First bit offset"] + #[inline] + pub fn fboff(&self) -> FBOFFR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FBOFFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - Slot enable"] + #[inline] + pub fn sloten(&mut self) -> _SLOTENW { + _SLOTENW { w: self } + } + #[doc = "Bits 8:11 - Number of slots in an audio frame"] + #[inline] + pub fn nbslot(&mut self) -> _NBSLOTW { + _NBSLOTW { w: self } + } + #[doc = "Bits 6:7 - Slot size"] + #[inline] + pub fn slotsz(&mut self) -> _SLOTSZW { + _SLOTSZW { w: self } + } + #[doc = "Bits 0:4 - First bit offset"] + #[inline] + pub fn fboff(&mut self) -> _FBOFFW { + _FBOFFW { w: self } + } +} diff --git a/src/sai/bsr/mod.rs b/src/sai/bsr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4737156a9244025ffe1d76d29c3a2228a341fd6a --- /dev/null +++ b/src/sai/bsr/mod.rs @@ -0,0 +1,258 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::BSR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct FLVLR { + bits: u8, +} +impl FLVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct LFSDETR { + bits: bool, +} +impl LFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AFSDETR { + bits: bool, +} +impl AFSDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CNRDYR { + bits: bool, +} +impl CNRDYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FREQR { + bits: bool, +} +impl FREQR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WCKCFGR { + bits: bool, +} +impl WCKCFGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MUTEDETR { + bits: bool, +} +impl MUTEDETR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OVRUDRR { + bits: bool, +} +impl OVRUDRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:18 - FIFO level threshold"] + #[inline] + pub fn flvl(&self) -> FLVLR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + FLVLR { bits } + } + #[doc = "Bit 6 - Late frame synchronization detection"] + #[inline] + pub fn lfsdet(&self) -> LFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LFSDETR { bits } + } + #[doc = "Bit 5 - Anticipated frame synchronization detection"] + #[inline] + pub fn afsdet(&self) -> AFSDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AFSDETR { bits } + } + #[doc = "Bit 4 - Codec not ready"] + #[inline] + pub fn cnrdy(&self) -> CNRDYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CNRDYR { bits } + } + #[doc = "Bit 3 - FIFO request"] + #[inline] + pub fn freq(&self) -> FREQR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FREQR { bits } + } + #[doc = "Bit 2 - Wrong clock configuration flag"] + #[inline] + pub fn wckcfg(&self) -> WCKCFGR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WCKCFGR { bits } + } + #[doc = "Bit 1 - Mute detection"] + #[inline] + pub fn mutedet(&self) -> MUTEDETR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MUTEDETR { bits } + } + #[doc = "Bit 0 - Overrun / underrun"] + #[inline] + pub fn ovrudr(&self) -> OVRUDRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVRUDRR { bits } + } +} diff --git a/src/sai/mod.rs b/src/sai/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..73a7fbed8e980194243c19cf7a2e6ae6d4586fcc --- /dev/null +++ b/src/sai/mod.rs @@ -0,0 +1,133 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + _reserved0: [u8; 4usize], + #[doc = "0x04 - AConfiguration register 1"] + pub acr1: ACR1, + #[doc = "0x08 - AConfiguration register 2"] + pub acr2: ACR2, + #[doc = "0x0c - AFRCR"] + pub afrcr: AFRCR, + #[doc = "0x10 - ASlot register"] + pub aslotr: ASLOTR, + #[doc = "0x14 - AInterrupt mask register2"] + pub aim: AIM, + #[doc = "0x18 - AStatus register"] + pub asr: ASR, + #[doc = "0x1c - AClear flag register"] + pub aclrfr: ACLRFR, + #[doc = "0x20 - AData register"] + pub adr: ADR, + #[doc = "0x24 - BConfiguration register 1"] + pub bcr1: BCR1, + #[doc = "0x28 - BConfiguration register 2"] + pub bcr2: BCR2, + #[doc = "0x2c - BFRCR"] + pub bfrcr: BFRCR, + #[doc = "0x30 - BSlot register"] + pub bslotr: BSLOTR, + #[doc = "0x34 - BInterrupt mask register2"] + pub bim: BIM, + #[doc = "0x38 - BStatus register"] + pub bsr: BSR, + #[doc = "0x3c - BClear flag register"] + pub bclrfr: BCLRFR, + #[doc = "0x40 - BData register"] + pub bdr: BDR, +} +#[doc = "BConfiguration register 1"] +pub struct BCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BConfiguration register 1"] +pub mod bcr1; +#[doc = "BConfiguration register 2"] +pub struct BCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BConfiguration register 2"] +pub mod bcr2; +#[doc = "BFRCR"] +pub struct BFRCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BFRCR"] +pub mod bfrcr; +#[doc = "BSlot register"] +pub struct BSLOTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BSlot register"] +pub mod bslotr; +#[doc = "BInterrupt mask register2"] +pub struct BIM { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BInterrupt mask register2"] +pub mod bim; +#[doc = "BStatus register"] +pub struct BSR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BStatus register"] +pub mod bsr; +#[doc = "BClear flag register"] +pub struct BCLRFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BClear flag register"] +pub mod bclrfr; +#[doc = "BData register"] +pub struct BDR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "BData register"] +pub mod bdr; +#[doc = "AConfiguration register 1"] +pub struct ACR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AConfiguration register 1"] +pub mod acr1; +#[doc = "AConfiguration register 2"] +pub struct ACR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AConfiguration register 2"] +pub mod acr2; +#[doc = "AFRCR"] +pub struct AFRCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AFRCR"] +pub mod afrcr; +#[doc = "ASlot register"] +pub struct ASLOTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "ASlot register"] +pub mod aslotr; +#[doc = "AInterrupt mask register2"] +pub struct AIM { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AInterrupt mask register2"] +pub mod aim; +#[doc = "AStatus register"] +pub struct ASR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AStatus register"] +pub mod asr; +#[doc = "AClear flag register"] +pub struct ACLRFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AClear flag register"] +pub mod aclrfr; +#[doc = "AData register"] +pub struct ADR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "AData register"] +pub mod adr; diff --git a/src/sdio/arg/mod.rs b/src/sdio/arg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9c2d76cad8b4dc33c49ab21746fdade4725b0e29 --- /dev/null +++ b/src/sdio/arg/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARG { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CMDARGR { + bits: u32, +} +impl CMDARGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CMDARGW<'a> { + w: &'a mut W, +} +impl<'a> _CMDARGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Command argument"] + #[inline] + pub fn cmdarg(&self) -> CMDARGR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CMDARGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Command argument"] + #[inline] + pub fn cmdarg(&mut self) -> _CMDARGW { + _CMDARGW { w: self } + } +} diff --git a/src/sdio/clkcr/mod.rs b/src/sdio/clkcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ae5e5e1ad5868d38bcc98fb829d8ff8157f8844c --- /dev/null +++ b/src/sdio/clkcr/mod.rs @@ -0,0 +1,441 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CLKCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct HWFC_ENR { + bits: bool, +} +impl HWFC_ENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NEGEDGER { + bits: bool, +} +impl NEGEDGER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WIDBUSR { + bits: u8, +} +impl WIDBUSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct BYPASSR { + bits: bool, +} +impl BYPASSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PWRSAVR { + bits: bool, +} +impl PWRSAVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLKENR { + bits: bool, +} +impl CLKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CLKDIVR { + bits: u8, +} +impl CLKDIVR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _HWFC_ENW<'a> { + w: &'a mut W, +} +impl<'a> _HWFC_ENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NEGEDGEW<'a> { + w: &'a mut W, +} +impl<'a> _NEGEDGEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WIDBUSW<'a> { + w: &'a mut W, +} +impl<'a> _WIDBUSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BYPASSW<'a> { + w: &'a mut W, +} +impl<'a> _BYPASSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PWRSAVW<'a> { + w: &'a mut W, +} +impl<'a> _PWRSAVW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKENW<'a> { + w: &'a mut W, +} +impl<'a> _CLKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKDIVW<'a> { + w: &'a mut W, +} +impl<'a> _CLKDIVW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - HW Flow Control enable"] + #[inline] + pub fn hwfc_en(&self) -> HWFC_ENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HWFC_ENR { bits } + } + #[doc = "Bit 13 - SDIO_CK dephasing selection bit"] + #[inline] + pub fn negedge(&self) -> NEGEDGER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NEGEDGER { bits } + } + #[doc = "Bits 11:12 - Wide bus mode enable bit"] + #[inline] + pub fn widbus(&self) -> WIDBUSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WIDBUSR { bits } + } + #[doc = "Bit 10 - Clock divider bypass enable bit"] + #[inline] + pub fn bypass(&self) -> BYPASSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BYPASSR { bits } + } + #[doc = "Bit 9 - Power saving configuration bit"] + #[inline] + pub fn pwrsav(&self) -> PWRSAVR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PWRSAVR { bits } + } + #[doc = "Bit 8 - Clock enable bit"] + #[inline] + pub fn clken(&self) -> CLKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLKENR { bits } + } + #[doc = "Bits 0:7 - Clock divide factor"] + #[inline] + pub fn clkdiv(&self) -> CLKDIVR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CLKDIVR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - HW Flow Control enable"] + #[inline] + pub fn hwfc_en(&mut self) -> _HWFC_ENW { + _HWFC_ENW { w: self } + } + #[doc = "Bit 13 - SDIO_CK dephasing selection bit"] + #[inline] + pub fn negedge(&mut self) -> _NEGEDGEW { + _NEGEDGEW { w: self } + } + #[doc = "Bits 11:12 - Wide bus mode enable bit"] + #[inline] + pub fn widbus(&mut self) -> _WIDBUSW { + _WIDBUSW { w: self } + } + #[doc = "Bit 10 - Clock divider bypass enable bit"] + #[inline] + pub fn bypass(&mut self) -> _BYPASSW { + _BYPASSW { w: self } + } + #[doc = "Bit 9 - Power saving configuration bit"] + #[inline] + pub fn pwrsav(&mut self) -> _PWRSAVW { + _PWRSAVW { w: self } + } + #[doc = "Bit 8 - Clock enable bit"] + #[inline] + pub fn clken(&mut self) -> _CLKENW { + _CLKENW { w: self } + } + #[doc = "Bits 0:7 - Clock divide factor"] + #[inline] + pub fn clkdiv(&mut self) -> _CLKDIVW { + _CLKDIVW { w: self } + } +} diff --git a/src/sdio/cmd/mod.rs b/src/sdio/cmd/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da2cdad99b6022db0bb5973477114cb6613bd8cf --- /dev/null +++ b/src/sdio/cmd/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CMD { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CE_ATACMDR { + bits: bool, +} +impl CE_ATACMDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NIENR { + bits: bool, +} +impl NIENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ENCMDCOMPLR { + bits: bool, +} +impl ENCMDCOMPLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOSUSPENDR { + bits: bool, +} +impl SDIOSUSPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CPSMENR { + bits: bool, +} +impl CPSMENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITPENDR { + bits: bool, +} +impl WAITPENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITINTR { + bits: bool, +} +impl WAITINTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAITRESPR { + bits: u8, +} +impl WAITRESPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CMDINDEXR { + bits: u8, +} +impl CMDINDEXR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CE_ATACMDW<'a> { + w: &'a mut W, +} +impl<'a> _CE_ATACMDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NIENW<'a> { + w: &'a mut W, +} +impl<'a> _NIENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ENCMDCOMPLW<'a> { + w: &'a mut W, +} +impl<'a> _ENCMDCOMPLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIOSUSPENDW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOSUSPENDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPSMENW<'a> { + w: &'a mut W, +} +impl<'a> _CPSMENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITPENDW<'a> { + w: &'a mut W, +} +impl<'a> _WAITPENDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITINTW<'a> { + w: &'a mut W, +} +impl<'a> _WAITINTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAITRESPW<'a> { + w: &'a mut W, +} +impl<'a> _WAITRESPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDINDEXW<'a> { + w: &'a mut W, +} +impl<'a> _CMDINDEXW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - CE-ATA command"] + #[inline] + pub fn ce_atacmd(&self) -> CE_ATACMDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CE_ATACMDR { bits } + } + #[doc = "Bit 13 - not Interrupt Enable"] + #[inline] + pub fn n_ien(&self) -> NIENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NIENR { bits } + } + #[doc = "Bit 12 - Enable CMD completion"] + #[inline] + pub fn encmdcompl(&self) -> ENCMDCOMPLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ENCMDCOMPLR { bits } + } + #[doc = "Bit 11 - SD I/O suspend command"] + #[inline] + pub fn sdiosuspend(&self) -> SDIOSUSPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOSUSPENDR { bits } + } + #[doc = "Bit 10 - Command path state machine (CPSM) Enable bit"] + #[inline] + pub fn cpsmen(&self) -> CPSMENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPSMENR { bits } + } + #[doc = "Bit 9 - CPSM Waits for ends of data transfer (CmdPend internal signal)."] + #[inline] + pub fn waitpend(&self) -> WAITPENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITPENDR { bits } + } + #[doc = "Bit 8 - CPSM waits for interrupt request"] + #[inline] + pub fn waitint(&self) -> WAITINTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAITINTR { bits } + } + #[doc = "Bits 6:7 - Wait for response bits"] + #[inline] + pub fn waitresp(&self) -> WAITRESPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WAITRESPR { bits } + } + #[doc = "Bits 0:5 - Command index"] + #[inline] + pub fn cmdindex(&self) -> CMDINDEXR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CMDINDEXR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - CE-ATA command"] + #[inline] + pub fn ce_atacmd(&mut self) -> _CE_ATACMDW { + _CE_ATACMDW { w: self } + } + #[doc = "Bit 13 - not Interrupt Enable"] + #[inline] + pub fn n_ien(&mut self) -> _NIENW { + _NIENW { w: self } + } + #[doc = "Bit 12 - Enable CMD completion"] + #[inline] + pub fn encmdcompl(&mut self) -> _ENCMDCOMPLW { + _ENCMDCOMPLW { w: self } + } + #[doc = "Bit 11 - SD I/O suspend command"] + #[inline] + pub fn sdiosuspend(&mut self) -> _SDIOSUSPENDW { + _SDIOSUSPENDW { w: self } + } + #[doc = "Bit 10 - Command path state machine (CPSM) Enable bit"] + #[inline] + pub fn cpsmen(&mut self) -> _CPSMENW { + _CPSMENW { w: self } + } + #[doc = "Bit 9 - CPSM Waits for ends of data transfer (CmdPend internal signal)."] + #[inline] + pub fn waitpend(&mut self) -> _WAITPENDW { + _WAITPENDW { w: self } + } + #[doc = "Bit 8 - CPSM waits for interrupt request"] + #[inline] + pub fn waitint(&mut self) -> _WAITINTW { + _WAITINTW { w: self } + } + #[doc = "Bits 6:7 - Wait for response bits"] + #[inline] + pub fn waitresp(&mut self) -> _WAITRESPW { + _WAITRESPW { w: self } + } + #[doc = "Bits 0:5 - Command index"] + #[inline] + pub fn cmdindex(&mut self) -> _CMDINDEXW { + _CMDINDEXW { w: self } + } +} diff --git a/src/sdio/dcount/mod.rs b/src/sdio/dcount/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a2ed596d8d38158be076c72fadfbf6f66a2ac625 --- /dev/null +++ b/src/sdio/dcount/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::DCOUNT { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct DATACOUNTR { + bits: u32, +} +impl DATACOUNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:24 - Data count value"] + #[inline] + pub fn datacount(&self) -> DATACOUNTR { + let bits = { + const MASK: u32 = 33554431; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATACOUNTR { bits } + } +} diff --git a/src/sdio/dctrl/mod.rs b/src/sdio/dctrl/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..901f66f71c4fe3bcc580481c61e5459db9115c0a --- /dev/null +++ b/src/sdio/dctrl/mod.rs @@ -0,0 +1,577 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCTRL { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct SDIOENR { + bits: bool, +} +impl SDIOENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RWMODR { + bits: bool, +} +impl RWMODR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RWSTOPR { + bits: bool, +} +impl RWSTOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RWSTARTR { + bits: bool, +} +impl RWSTARTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBLOCKSIZER { + bits: u8, +} +impl DBLOCKSIZER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DMAENR { + bits: bool, +} +impl DMAENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTMODER { + bits: bool, +} +impl DTMODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTDIRR { + bits: bool, +} +impl DTDIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTENR { + bits: bool, +} +impl DTENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _SDIOENW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RWMODW<'a> { + w: &'a mut W, +} +impl<'a> _RWMODW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RWSTOPW<'a> { + w: &'a mut W, +} +impl<'a> _RWSTOPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RWSTARTW<'a> { + w: &'a mut W, +} +impl<'a> _RWSTARTW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBLOCKSIZEW<'a> { + w: &'a mut W, +} +impl<'a> _DBLOCKSIZEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMAENW<'a> { + w: &'a mut W, +} +impl<'a> _DMAENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTMODEW<'a> { + w: &'a mut W, +} +impl<'a> _DTMODEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTDIRW<'a> { + w: &'a mut W, +} +impl<'a> _DTDIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTENW<'a> { + w: &'a mut W, +} +impl<'a> _DTENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 11 - SD I/O enable functions"] + #[inline] + pub fn sdioen(&self) -> SDIOENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOENR { bits } + } + #[doc = "Bit 10 - Read wait mode"] + #[inline] + pub fn rwmod(&self) -> RWMODR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RWMODR { bits } + } + #[doc = "Bit 9 - Read wait stop"] + #[inline] + pub fn rwstop(&self) -> RWSTOPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RWSTOPR { bits } + } + #[doc = "Bit 8 - Read wait start"] + #[inline] + pub fn rwstart(&self) -> RWSTARTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RWSTARTR { bits } + } + #[doc = "Bits 4:7 - Data block size"] + #[inline] + pub fn dblocksize(&self) -> DBLOCKSIZER { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBLOCKSIZER { bits } + } + #[doc = "Bit 3 - DMA enable bit"] + #[inline] + pub fn dmaen(&self) -> DMAENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMAENR { bits } + } + #[doc = "Bit 2 - Data transfer mode selection 1: Stream or SDIO multibyte data transfer."] + #[inline] + pub fn dtmode(&self) -> DTMODER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTMODER { bits } + } + #[doc = "Bit 1 - Data transfer direction selection"] + #[inline] + pub fn dtdir(&self) -> DTDIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTDIRR { bits } + } + #[doc = "Bit 0 - DTEN"] + #[inline] + pub fn dten(&self) -> DTENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 11 - SD I/O enable functions"] + #[inline] + pub fn sdioen(&mut self) -> _SDIOENW { + _SDIOENW { w: self } + } + #[doc = "Bit 10 - Read wait mode"] + #[inline] + pub fn rwmod(&mut self) -> _RWMODW { + _RWMODW { w: self } + } + #[doc = "Bit 9 - Read wait stop"] + #[inline] + pub fn rwstop(&mut self) -> _RWSTOPW { + _RWSTOPW { w: self } + } + #[doc = "Bit 8 - Read wait start"] + #[inline] + pub fn rwstart(&mut self) -> _RWSTARTW { + _RWSTARTW { w: self } + } + #[doc = "Bits 4:7 - Data block size"] + #[inline] + pub fn dblocksize(&mut self) -> _DBLOCKSIZEW { + _DBLOCKSIZEW { w: self } + } + #[doc = "Bit 3 - DMA enable bit"] + #[inline] + pub fn dmaen(&mut self) -> _DMAENW { + _DMAENW { w: self } + } + #[doc = "Bit 2 - Data transfer mode selection 1: Stream or SDIO multibyte data transfer."] + #[inline] + pub fn dtmode(&mut self) -> _DTMODEW { + _DTMODEW { w: self } + } + #[doc = "Bit 1 - Data transfer direction selection"] + #[inline] + pub fn dtdir(&mut self) -> _DTDIRW { + _DTDIRW { w: self } + } + #[doc = "Bit 0 - DTEN"] + #[inline] + pub fn dten(&mut self) -> _DTENW { + _DTENW { w: self } + } +} diff --git a/src/sdio/dlen/mod.rs b/src/sdio/dlen/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..5732c96e75b8ae9e3fbf63c8cdb1230c5fe4877d --- /dev/null +++ b/src/sdio/dlen/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DLEN { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATALENGTHR { + bits: u32, +} +impl DATALENGTHR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATALENGTHW<'a> { + w: &'a mut W, +} +impl<'a> _DATALENGTHW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 33554431; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:24 - Data length value"] + #[inline] + pub fn datalength(&self) -> DATALENGTHR { + let bits = { + const MASK: u32 = 33554431; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATALENGTHR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:24 - Data length value"] + #[inline] + pub fn datalength(&mut self) -> _DATALENGTHW { + _DATALENGTHW { w: self } + } +} diff --git a/src/sdio/dtimer/mod.rs b/src/sdio/dtimer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f5640b33d3b725755f61041f84541da63f71c102 --- /dev/null +++ b/src/sdio/dtimer/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DTIMER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DATATIMER { + bits: u32, +} +impl DATATIMER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DATATIMEW<'a> { + w: &'a mut W, +} +impl<'a> _DATATIMEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Data timeout period"] + #[inline] + pub fn datatime(&self) -> DATATIMER { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + DATATIMER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Data timeout period"] + #[inline] + pub fn datatime(&mut self) -> _DATATIMEW { + _DATATIMEW { w: self } + } +} diff --git a/src/sdio/fifo/mod.rs b/src/sdio/fifo/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..741216176185b18523f6ad718d6a94ff470e7373 --- /dev/null +++ b/src/sdio/fifo/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::FIFO { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct FIFODATAR { + bits: u32, +} +impl FIFODATAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _FIFODATAW<'a> { + w: &'a mut W, +} +impl<'a> _FIFODATAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u32) -> &'a mut W { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Receive and transmit FIFO data"] + #[inline] + pub fn fifodata(&self) -> FIFODATAR { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + FIFODATAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:31 - Receive and transmit FIFO data"] + #[inline] + pub fn fifodata(&mut self) -> _FIFODATAW { + _FIFODATAW { w: self } + } +} diff --git a/src/sdio/fifocnt/mod.rs b/src/sdio/fifocnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f2abba61ea50d07c36438ff643d414c9d1782beb --- /dev/null +++ b/src/sdio/fifocnt/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::FIFOCNT { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct FIFOCOUNTR { + bits: u32, +} +impl FIFOCOUNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:23 - Remaining number of words to be written to or read from the FIFO."] + #[inline] + pub fn fifocount(&self) -> FIFOCOUNTR { + let bits = { + const MASK: u32 = 16777215; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + FIFOCOUNTR { bits } + } +} diff --git a/src/sdio/icr/mod.rs b/src/sdio/icr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61937d3e1bfab4abe4f6b61faaf2118e33fc19a6 --- /dev/null +++ b/src/sdio/icr/mod.rs @@ -0,0 +1,831 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ICR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CEATAENDCR { + bits: bool, +} +impl CEATAENDCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOITCR { + bits: bool, +} +impl SDIOITCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBCKENDCR { + bits: bool, +} +impl DBCKENDCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STBITERRCR { + bits: bool, +} +impl STBITERRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DATAENDCR { + bits: bool, +} +impl DATAENDCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDSENTCR { + bits: bool, +} +impl CMDSENTCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDRENDCR { + bits: bool, +} +impl CMDRENDCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXOVERRCR { + bits: bool, +} +impl RXOVERRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXUNDERRCR { + bits: bool, +} +impl TXUNDERRCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTIMEOUTCR { + bits: bool, +} +impl DTIMEOUTCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTIMEOUTCR { + bits: bool, +} +impl CTIMEOUTCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCRCFAILCR { + bits: bool, +} +impl DCRCFAILCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCRCFAILCR { + bits: bool, +} +impl CCRCFAILCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CEATAENDCW<'a> { + w: &'a mut W, +} +impl<'a> _CEATAENDCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIOITCW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOITCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBCKENDCW<'a> { + w: &'a mut W, +} +impl<'a> _DBCKENDCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STBITERRCW<'a> { + w: &'a mut W, +} +impl<'a> _STBITERRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATAENDCW<'a> { + w: &'a mut W, +} +impl<'a> _DATAENDCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDSENTCW<'a> { + w: &'a mut W, +} +impl<'a> _CMDSENTCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDRENDCW<'a> { + w: &'a mut W, +} +impl<'a> _CMDRENDCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXOVERRCW<'a> { + w: &'a mut W, +} +impl<'a> _RXOVERRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXUNDERRCW<'a> { + w: &'a mut W, +} +impl<'a> _TXUNDERRCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTIMEOUTCW<'a> { + w: &'a mut W, +} +impl<'a> _DTIMEOUTCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTIMEOUTCW<'a> { + w: &'a mut W, +} +impl<'a> _CTIMEOUTCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCRCFAILCW<'a> { + w: &'a mut W, +} +impl<'a> _DCRCFAILCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCRCFAILCW<'a> { + w: &'a mut W, +} +impl<'a> _CCRCFAILCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 23 - CEATAEND flag clear bit"] + #[inline] + pub fn ceataendc(&self) -> CEATAENDCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CEATAENDCR { bits } + } + #[doc = "Bit 22 - SDIOIT flag clear bit"] + #[inline] + pub fn sdioitc(&self) -> SDIOITCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOITCR { bits } + } + #[doc = "Bit 10 - DBCKEND flag clear bit"] + #[inline] + pub fn dbckendc(&self) -> DBCKENDCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBCKENDCR { bits } + } + #[doc = "Bit 9 - STBITERR flag clear bit"] + #[inline] + pub fn stbiterrc(&self) -> STBITERRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STBITERRCR { bits } + } + #[doc = "Bit 8 - DATAEND flag clear bit"] + #[inline] + pub fn dataendc(&self) -> DATAENDCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DATAENDCR { bits } + } + #[doc = "Bit 7 - CMDSENT flag clear bit"] + #[inline] + pub fn cmdsentc(&self) -> CMDSENTCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDSENTCR { bits } + } + #[doc = "Bit 6 - CMDREND flag clear bit"] + #[inline] + pub fn cmdrendc(&self) -> CMDRENDCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDRENDCR { bits } + } + #[doc = "Bit 5 - RXOVERR flag clear bit"] + #[inline] + pub fn rxoverrc(&self) -> RXOVERRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXOVERRCR { bits } + } + #[doc = "Bit 4 - TXUNDERR flag clear bit"] + #[inline] + pub fn txunderrc(&self) -> TXUNDERRCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXUNDERRCR { bits } + } + #[doc = "Bit 3 - DTIMEOUT flag clear bit"] + #[inline] + pub fn dtimeoutc(&self) -> DTIMEOUTCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTIMEOUTCR { bits } + } + #[doc = "Bit 2 - CTIMEOUT flag clear bit"] + #[inline] + pub fn ctimeoutc(&self) -> CTIMEOUTCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTIMEOUTCR { bits } + } + #[doc = "Bit 1 - DCRCFAIL flag clear bit"] + #[inline] + pub fn dcrcfailc(&self) -> DCRCFAILCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCRCFAILCR { bits } + } + #[doc = "Bit 0 - CCRCFAIL flag clear bit"] + #[inline] + pub fn ccrcfailc(&self) -> CCRCFAILCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCRCFAILCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 23 - CEATAEND flag clear bit"] + #[inline] + pub fn ceataendc(&mut self) -> _CEATAENDCW { + _CEATAENDCW { w: self } + } + #[doc = "Bit 22 - SDIOIT flag clear bit"] + #[inline] + pub fn sdioitc(&mut self) -> _SDIOITCW { + _SDIOITCW { w: self } + } + #[doc = "Bit 10 - DBCKEND flag clear bit"] + #[inline] + pub fn dbckendc(&mut self) -> _DBCKENDCW { + _DBCKENDCW { w: self } + } + #[doc = "Bit 9 - STBITERR flag clear bit"] + #[inline] + pub fn stbiterrc(&mut self) -> _STBITERRCW { + _STBITERRCW { w: self } + } + #[doc = "Bit 8 - DATAEND flag clear bit"] + #[inline] + pub fn dataendc(&mut self) -> _DATAENDCW { + _DATAENDCW { w: self } + } + #[doc = "Bit 7 - CMDSENT flag clear bit"] + #[inline] + pub fn cmdsentc(&mut self) -> _CMDSENTCW { + _CMDSENTCW { w: self } + } + #[doc = "Bit 6 - CMDREND flag clear bit"] + #[inline] + pub fn cmdrendc(&mut self) -> _CMDRENDCW { + _CMDRENDCW { w: self } + } + #[doc = "Bit 5 - RXOVERR flag clear bit"] + #[inline] + pub fn rxoverrc(&mut self) -> _RXOVERRCW { + _RXOVERRCW { w: self } + } + #[doc = "Bit 4 - TXUNDERR flag clear bit"] + #[inline] + pub fn txunderrc(&mut self) -> _TXUNDERRCW { + _TXUNDERRCW { w: self } + } + #[doc = "Bit 3 - DTIMEOUT flag clear bit"] + #[inline] + pub fn dtimeoutc(&mut self) -> _DTIMEOUTCW { + _DTIMEOUTCW { w: self } + } + #[doc = "Bit 2 - CTIMEOUT flag clear bit"] + #[inline] + pub fn ctimeoutc(&mut self) -> _CTIMEOUTCW { + _CTIMEOUTCW { w: self } + } + #[doc = "Bit 1 - DCRCFAIL flag clear bit"] + #[inline] + pub fn dcrcfailc(&mut self) -> _DCRCFAILCW { + _DCRCFAILCW { w: self } + } + #[doc = "Bit 0 - CCRCFAIL flag clear bit"] + #[inline] + pub fn ccrcfailc(&mut self) -> _CCRCFAILCW { + _CCRCFAILCW { w: self } + } +} diff --git a/src/sdio/mask/mod.rs b/src/sdio/mask/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e568b145fa3cbb4a56df3b97a57c835cdb1550f8 --- /dev/null +++ b/src/sdio/mask/mod.rs @@ -0,0 +1,1480 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MASK { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CEATAENDIER { + bits: bool, +} +impl CEATAENDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOITIER { + bits: bool, +} +impl SDIOITIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXDAVLIER { + bits: bool, +} +impl RXDAVLIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXDAVLIER { + bits: bool, +} +impl TXDAVLIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOEIER { + bits: bool, +} +impl RXFIFOEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOEIER { + bits: bool, +} +impl TXFIFOEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOFIER { + bits: bool, +} +impl RXFIFOFIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOFIER { + bits: bool, +} +impl TXFIFOFIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOHFIER { + bits: bool, +} +impl RXFIFOHFIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOHEIER { + bits: bool, +} +impl TXFIFOHEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXACTIER { + bits: bool, +} +impl RXACTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXACTIER { + bits: bool, +} +impl TXACTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDACTIER { + bits: bool, +} +impl CMDACTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBCKENDIER { + bits: bool, +} +impl DBCKENDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STBITERRIER { + bits: bool, +} +impl STBITERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DATAENDIER { + bits: bool, +} +impl DATAENDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDSENTIER { + bits: bool, +} +impl CMDSENTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDRENDIER { + bits: bool, +} +impl CMDRENDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXOVERRIER { + bits: bool, +} +impl RXOVERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXUNDERRIER { + bits: bool, +} +impl TXUNDERRIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTIMEOUTIER { + bits: bool, +} +impl DTIMEOUTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTIMEOUTIER { + bits: bool, +} +impl CTIMEOUTIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCRCFAILIER { + bits: bool, +} +impl DCRCFAILIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCRCFAILIER { + bits: bool, +} +impl CCRCFAILIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CEATAENDIEW<'a> { + w: &'a mut W, +} +impl<'a> _CEATAENDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 23; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SDIOITIEW<'a> { + w: &'a mut W, +} +impl<'a> _SDIOITIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 22; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXDAVLIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXDAVLIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 21; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXDAVLIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXDAVLIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 20; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXFIFOEIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXFIFOEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 19; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFIFOEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXFIFOEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 18; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXFIFOFIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXFIFOFIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 17; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFIFOFIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXFIFOFIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXFIFOHFIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXFIFOHFIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXFIFOHEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXFIFOHEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXACTIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXACTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXACTIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXACTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDACTIEW<'a> { + w: &'a mut W, +} +impl<'a> _CMDACTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBCKENDIEW<'a> { + w: &'a mut W, +} +impl<'a> _DBCKENDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STBITERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _STBITERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DATAENDIEW<'a> { + w: &'a mut W, +} +impl<'a> _DATAENDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDSENTIEW<'a> { + w: &'a mut W, +} +impl<'a> _CMDSENTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMDRENDIEW<'a> { + w: &'a mut W, +} +impl<'a> _CMDRENDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXOVERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXOVERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXUNDERRIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXUNDERRIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTIMEOUTIEW<'a> { + w: &'a mut W, +} +impl<'a> _DTIMEOUTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTIMEOUTIEW<'a> { + w: &'a mut W, +} +impl<'a> _CTIMEOUTIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DCRCFAILIEW<'a> { + w: &'a mut W, +} +impl<'a> _DCRCFAILIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCRCFAILIEW<'a> { + w: &'a mut W, +} +impl<'a> _CCRCFAILIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 23 - CE-ATA command completion signal received interrupt enable"] + #[inline] + pub fn ceataendie(&self) -> CEATAENDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CEATAENDIER { bits } + } + #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"] + #[inline] + pub fn sdioitie(&self) -> SDIOITIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOITIER { bits } + } + #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"] + #[inline] + pub fn rxdavlie(&self) -> RXDAVLIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXDAVLIER { bits } + } + #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"] + #[inline] + pub fn txdavlie(&self) -> TXDAVLIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXDAVLIER { bits } + } + #[doc = "Bit 19 - Rx FIFO empty interrupt enable"] + #[inline] + pub fn rxfifoeie(&self) -> RXFIFOEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOEIER { bits } + } + #[doc = "Bit 18 - Tx FIFO empty interrupt enable"] + #[inline] + pub fn txfifoeie(&self) -> TXFIFOEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOEIER { bits } + } + #[doc = "Bit 17 - Rx FIFO full interrupt enable"] + #[inline] + pub fn rxfifofie(&self) -> RXFIFOFIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOFIER { bits } + } + #[doc = "Bit 16 - Tx FIFO full interrupt enable"] + #[inline] + pub fn txfifofie(&self) -> TXFIFOFIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOFIER { bits } + } + #[doc = "Bit 15 - Rx FIFO half full interrupt enable"] + #[inline] + pub fn rxfifohfie(&self) -> RXFIFOHFIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOHFIER { bits } + } + #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"] + #[inline] + pub fn txfifoheie(&self) -> TXFIFOHEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOHEIER { bits } + } + #[doc = "Bit 13 - Data receive acting interrupt enable"] + #[inline] + pub fn rxactie(&self) -> RXACTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXACTIER { bits } + } + #[doc = "Bit 12 - Data transmit acting interrupt enable"] + #[inline] + pub fn txactie(&self) -> TXACTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXACTIER { bits } + } + #[doc = "Bit 11 - Command acting interrupt enable"] + #[inline] + pub fn cmdactie(&self) -> CMDACTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDACTIER { bits } + } + #[doc = "Bit 10 - Data block end interrupt enable"] + #[inline] + pub fn dbckendie(&self) -> DBCKENDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBCKENDIER { bits } + } + #[doc = "Bit 9 - Start bit error interrupt enable"] + #[inline] + pub fn stbiterrie(&self) -> STBITERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STBITERRIER { bits } + } + #[doc = "Bit 8 - Data end interrupt enable"] + #[inline] + pub fn dataendie(&self) -> DATAENDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DATAENDIER { bits } + } + #[doc = "Bit 7 - Command sent interrupt enable"] + #[inline] + pub fn cmdsentie(&self) -> CMDSENTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDSENTIER { bits } + } + #[doc = "Bit 6 - Command response received interrupt enable"] + #[inline] + pub fn cmdrendie(&self) -> CMDRENDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDRENDIER { bits } + } + #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"] + #[inline] + pub fn rxoverrie(&self) -> RXOVERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXOVERRIER { bits } + } + #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"] + #[inline] + pub fn txunderrie(&self) -> TXUNDERRIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXUNDERRIER { bits } + } + #[doc = "Bit 3 - Data timeout interrupt enable"] + #[inline] + pub fn dtimeoutie(&self) -> DTIMEOUTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTIMEOUTIER { bits } + } + #[doc = "Bit 2 - Command timeout interrupt enable"] + #[inline] + pub fn ctimeoutie(&self) -> CTIMEOUTIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTIMEOUTIER { bits } + } + #[doc = "Bit 1 - Data CRC fail interrupt enable"] + #[inline] + pub fn dcrcfailie(&self) -> DCRCFAILIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCRCFAILIER { bits } + } + #[doc = "Bit 0 - Command CRC fail interrupt enable"] + #[inline] + pub fn ccrcfailie(&self) -> CCRCFAILIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCRCFAILIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 23 - CE-ATA command completion signal received interrupt enable"] + #[inline] + pub fn ceataendie(&mut self) -> _CEATAENDIEW { + _CEATAENDIEW { w: self } + } + #[doc = "Bit 22 - SDIO mode interrupt received interrupt enable"] + #[inline] + pub fn sdioitie(&mut self) -> _SDIOITIEW { + _SDIOITIEW { w: self } + } + #[doc = "Bit 21 - Data available in Rx FIFO interrupt enable"] + #[inline] + pub fn rxdavlie(&mut self) -> _RXDAVLIEW { + _RXDAVLIEW { w: self } + } + #[doc = "Bit 20 - Data available in Tx FIFO interrupt enable"] + #[inline] + pub fn txdavlie(&mut self) -> _TXDAVLIEW { + _TXDAVLIEW { w: self } + } + #[doc = "Bit 19 - Rx FIFO empty interrupt enable"] + #[inline] + pub fn rxfifoeie(&mut self) -> _RXFIFOEIEW { + _RXFIFOEIEW { w: self } + } + #[doc = "Bit 18 - Tx FIFO empty interrupt enable"] + #[inline] + pub fn txfifoeie(&mut self) -> _TXFIFOEIEW { + _TXFIFOEIEW { w: self } + } + #[doc = "Bit 17 - Rx FIFO full interrupt enable"] + #[inline] + pub fn rxfifofie(&mut self) -> _RXFIFOFIEW { + _RXFIFOFIEW { w: self } + } + #[doc = "Bit 16 - Tx FIFO full interrupt enable"] + #[inline] + pub fn txfifofie(&mut self) -> _TXFIFOFIEW { + _TXFIFOFIEW { w: self } + } + #[doc = "Bit 15 - Rx FIFO half full interrupt enable"] + #[inline] + pub fn rxfifohfie(&mut self) -> _RXFIFOHFIEW { + _RXFIFOHFIEW { w: self } + } + #[doc = "Bit 14 - Tx FIFO half empty interrupt enable"] + #[inline] + pub fn txfifoheie(&mut self) -> _TXFIFOHEIEW { + _TXFIFOHEIEW { w: self } + } + #[doc = "Bit 13 - Data receive acting interrupt enable"] + #[inline] + pub fn rxactie(&mut self) -> _RXACTIEW { + _RXACTIEW { w: self } + } + #[doc = "Bit 12 - Data transmit acting interrupt enable"] + #[inline] + pub fn txactie(&mut self) -> _TXACTIEW { + _TXACTIEW { w: self } + } + #[doc = "Bit 11 - Command acting interrupt enable"] + #[inline] + pub fn cmdactie(&mut self) -> _CMDACTIEW { + _CMDACTIEW { w: self } + } + #[doc = "Bit 10 - Data block end interrupt enable"] + #[inline] + pub fn dbckendie(&mut self) -> _DBCKENDIEW { + _DBCKENDIEW { w: self } + } + #[doc = "Bit 9 - Start bit error interrupt enable"] + #[inline] + pub fn stbiterrie(&mut self) -> _STBITERRIEW { + _STBITERRIEW { w: self } + } + #[doc = "Bit 8 - Data end interrupt enable"] + #[inline] + pub fn dataendie(&mut self) -> _DATAENDIEW { + _DATAENDIEW { w: self } + } + #[doc = "Bit 7 - Command sent interrupt enable"] + #[inline] + pub fn cmdsentie(&mut self) -> _CMDSENTIEW { + _CMDSENTIEW { w: self } + } + #[doc = "Bit 6 - Command response received interrupt enable"] + #[inline] + pub fn cmdrendie(&mut self) -> _CMDRENDIEW { + _CMDRENDIEW { w: self } + } + #[doc = "Bit 5 - Rx FIFO overrun error interrupt enable"] + #[inline] + pub fn rxoverrie(&mut self) -> _RXOVERRIEW { + _RXOVERRIEW { w: self } + } + #[doc = "Bit 4 - Tx FIFO underrun error interrupt enable"] + #[inline] + pub fn txunderrie(&mut self) -> _TXUNDERRIEW { + _TXUNDERRIEW { w: self } + } + #[doc = "Bit 3 - Data timeout interrupt enable"] + #[inline] + pub fn dtimeoutie(&mut self) -> _DTIMEOUTIEW { + _DTIMEOUTIEW { w: self } + } + #[doc = "Bit 2 - Command timeout interrupt enable"] + #[inline] + pub fn ctimeoutie(&mut self) -> _CTIMEOUTIEW { + _CTIMEOUTIEW { w: self } + } + #[doc = "Bit 1 - Data CRC fail interrupt enable"] + #[inline] + pub fn dcrcfailie(&mut self) -> _DCRCFAILIEW { + _DCRCFAILIEW { w: self } + } + #[doc = "Bit 0 - Command CRC fail interrupt enable"] + #[inline] + pub fn ccrcfailie(&mut self) -> _CCRCFAILIEW { + _CCRCFAILIEW { w: self } + } +} diff --git a/src/sdio/mod.rs b/src/sdio/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..09c662ec99c320d057a9ac7ce9084a0ff2401f7b --- /dev/null +++ b/src/sdio/mod.rs @@ -0,0 +1,150 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - power control register"] + pub power: POWER, + #[doc = "0x04 - SDI clock control register"] + pub clkcr: CLKCR, + #[doc = "0x08 - argument register"] + pub arg: ARG, + #[doc = "0x0c - command register"] + pub cmd: CMD, + #[doc = "0x10 - command response register"] + pub respcmd: RESPCMD, + #[doc = "0x14 - response 1..4 register"] + pub resp1: RESP1, + #[doc = "0x18 - response 1..4 register"] + pub resp2: RESP2, + #[doc = "0x1c - response 1..4 register"] + pub resp3: RESP3, + #[doc = "0x20 - response 1..4 register"] + pub resp4: RESP4, + #[doc = "0x24 - data timer register"] + pub dtimer: DTIMER, + #[doc = "0x28 - data length register"] + pub dlen: DLEN, + #[doc = "0x2c - data control register"] + pub dctrl: DCTRL, + #[doc = "0x30 - data counter register"] + pub dcount: DCOUNT, + #[doc = "0x34 - status register"] + pub sta: STA, + #[doc = "0x38 - interrupt clear register"] + pub icr: ICR, + #[doc = "0x3c - mask register"] + pub mask: MASK, + _reserved0: [u8; 8usize], + #[doc = "0x48 - FIFO counter register"] + pub fifocnt: FIFOCNT, + _reserved1: [u8; 52usize], + #[doc = "0x80 - data FIFO register"] + pub fifo: FIFO, +} +#[doc = "power control register"] +pub struct POWER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "power control register"] +pub mod power; +#[doc = "SDI clock control register"] +pub struct CLKCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "SDI clock control register"] +pub mod clkcr; +#[doc = "argument register"] +pub struct ARG { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "argument register"] +pub mod arg; +#[doc = "command register"] +pub struct CMD { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "command register"] +pub mod cmd; +#[doc = "command response register"] +pub struct RESPCMD { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "command response register"] +pub mod respcmd; +#[doc = "response 1..4 register"] +pub struct RESP1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "response 1..4 register"] +pub mod resp1; +#[doc = "response 1..4 register"] +pub struct RESP2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "response 1..4 register"] +pub mod resp2; +#[doc = "response 1..4 register"] +pub struct RESP3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "response 1..4 register"] +pub mod resp3; +#[doc = "response 1..4 register"] +pub struct RESP4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "response 1..4 register"] +pub mod resp4; +#[doc = "data timer register"] +pub struct DTIMER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data timer register"] +pub mod dtimer; +#[doc = "data length register"] +pub struct DLEN { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data length register"] +pub mod dlen; +#[doc = "data control register"] +pub struct DCTRL { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data control register"] +pub mod dctrl; +#[doc = "data counter register"] +pub struct DCOUNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data counter register"] +pub mod dcount; +#[doc = "status register"] +pub struct STA { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sta; +#[doc = "interrupt clear register"] +pub struct ICR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "interrupt clear register"] +pub mod icr; +#[doc = "mask register"] +pub struct MASK { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "mask register"] +pub mod mask; +#[doc = "FIFO counter register"] +pub struct FIFOCNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "FIFO counter register"] +pub mod fifocnt; +#[doc = "data FIFO register"] +pub struct FIFO { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "data FIFO register"] +pub mod fifo; diff --git a/src/sdio/power/mod.rs b/src/sdio/power/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..14f116b123508994292d635c8bbf4bc370a2bf8c --- /dev/null +++ b/src/sdio/power/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::POWER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PWRCTRLR { + bits: u8, +} +impl PWRCTRLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PWRCTRLW<'a> { + w: &'a mut W, +} +impl<'a> _PWRCTRLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - PWRCTRL"] + #[inline] + pub fn pwrctrl(&self) -> PWRCTRLR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PWRCTRLR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - PWRCTRL"] + #[inline] + pub fn pwrctrl(&mut self) -> _PWRCTRLW { + _PWRCTRLW { w: self } + } +} diff --git a/src/sdio/resp1/mod.rs b/src/sdio/resp1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f0a0a37c060205e6bb286c12b3b46780b3fa1c73 --- /dev/null +++ b/src/sdio/resp1/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RESP1 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CARDSTATUS1R { + bits: u32, +} +impl CARDSTATUS1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Card Status"] + #[inline] + pub fn cardstatus1(&self) -> CARDSTATUS1R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CARDSTATUS1R { bits } + } +} diff --git a/src/sdio/resp2/mod.rs b/src/sdio/resp2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..576689504d5a7e1abc55c2131bb79c0ef4b4347f --- /dev/null +++ b/src/sdio/resp2/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RESP2 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CARDSTATUS2R { + bits: u32, +} +impl CARDSTATUS2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Card Status"] + #[inline] + pub fn cardstatus2(&self) -> CARDSTATUS2R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CARDSTATUS2R { bits } + } +} diff --git a/src/sdio/resp3/mod.rs b/src/sdio/resp3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f496a9c14a7b35b9d112a34ade119f6e27e5f023 --- /dev/null +++ b/src/sdio/resp3/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RESP3 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CARDSTATUS3R { + bits: u32, +} +impl CARDSTATUS3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Card Status"] + #[inline] + pub fn cardstatus3(&self) -> CARDSTATUS3R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CARDSTATUS3R { bits } + } +} diff --git a/src/sdio/resp4/mod.rs b/src/sdio/resp4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ca91950977c7fa1de00246fb90c4544ec67ee6c1 --- /dev/null +++ b/src/sdio/resp4/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RESP4 { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CARDSTATUS4R { + bits: u32, +} +impl CARDSTATUS4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:31 - Card Status"] + #[inline] + pub fn cardstatus4(&self) -> CARDSTATUS4R { + let bits = { + const MASK: u32 = 4294967295; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u32 + }; + CARDSTATUS4R { bits } + } +} diff --git a/src/sdio/respcmd/mod.rs b/src/sdio/respcmd/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a9b9697c25c40daa4d952057f0f65d12e5de128d --- /dev/null +++ b/src/sdio/respcmd/mod.rs @@ -0,0 +1,41 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::RESPCMD { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct RESPCMDR { + bits: u8, +} +impl RESPCMDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:5 - Response command index"] + #[inline] + pub fn respcmd(&self) -> RESPCMDR { + let bits = { + const MASK: u8 = 63; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RESPCMDR { bits } + } +} diff --git a/src/sdio/sta/mod.rs b/src/sdio/sta/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ba83d2f55ac822d2fc8fffab7050af7556f8911f --- /dev/null +++ b/src/sdio/sta/mod.rs @@ -0,0 +1,764 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::STA { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct CEATAENDR { + bits: bool, +} +impl CEATAENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SDIOITR { + bits: bool, +} +impl SDIOITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXDAVLR { + bits: bool, +} +impl RXDAVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXDAVLR { + bits: bool, +} +impl TXDAVLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOER { + bits: bool, +} +impl RXFIFOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOER { + bits: bool, +} +impl TXFIFOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOFR { + bits: bool, +} +impl RXFIFOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOFR { + bits: bool, +} +impl TXFIFOFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXFIFOHFR { + bits: bool, +} +impl RXFIFOHFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXFIFOHER { + bits: bool, +} +impl TXFIFOHER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXACTR { + bits: bool, +} +impl RXACTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXACTR { + bits: bool, +} +impl TXACTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDACTR { + bits: bool, +} +impl CMDACTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DBCKENDR { + bits: bool, +} +impl DBCKENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STBITERRR { + bits: bool, +} +impl STBITERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DATAENDR { + bits: bool, +} +impl DATAENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDSENTR { + bits: bool, +} +impl CMDSENTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMDRENDR { + bits: bool, +} +impl CMDRENDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXOVERRR { + bits: bool, +} +impl RXOVERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXUNDERRR { + bits: bool, +} +impl TXUNDERRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DTIMEOUTR { + bits: bool, +} +impl DTIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTIMEOUTR { + bits: bool, +} +impl CTIMEOUTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DCRCFAILR { + bits: bool, +} +impl DCRCFAILR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCRCFAILR { + bits: bool, +} +impl CCRCFAILR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 23 - CE-ATA command completion signal received for CMD61"] + #[inline] + pub fn ceataend(&self) -> CEATAENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 23; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CEATAENDR { bits } + } + #[doc = "Bit 22 - SDIO interrupt received"] + #[inline] + pub fn sdioit(&self) -> SDIOITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 22; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SDIOITR { bits } + } + #[doc = "Bit 21 - Data available in receive FIFO"] + #[inline] + pub fn rxdavl(&self) -> RXDAVLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 21; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXDAVLR { bits } + } + #[doc = "Bit 20 - Data available in transmit FIFO"] + #[inline] + pub fn txdavl(&self) -> TXDAVLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 20; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXDAVLR { bits } + } + #[doc = "Bit 19 - Receive FIFO empty"] + #[inline] + pub fn rxfifoe(&self) -> RXFIFOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 19; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOER { bits } + } + #[doc = "Bit 18 - Transmit FIFO empty"] + #[inline] + pub fn txfifoe(&self) -> TXFIFOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 18; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOER { bits } + } + #[doc = "Bit 17 - Receive FIFO full"] + #[inline] + pub fn rxfifof(&self) -> RXFIFOFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 17; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOFR { bits } + } + #[doc = "Bit 16 - Transmit FIFO full"] + #[inline] + pub fn txfifof(&self) -> TXFIFOFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOFR { bits } + } + #[doc = "Bit 15 - Receive FIFO half full: there are at least 8 words in the FIFO"] + #[inline] + pub fn rxfifohf(&self) -> RXFIFOHFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXFIFOHFR { bits } + } + #[doc = "Bit 14 - Transmit FIFO half empty: at least 8 words can be written into the FIFO"] + #[inline] + pub fn txfifohe(&self) -> TXFIFOHER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXFIFOHER { bits } + } + #[doc = "Bit 13 - Data receive in progress"] + #[inline] + pub fn rxact(&self) -> RXACTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXACTR { bits } + } + #[doc = "Bit 12 - Data transmit in progress"] + #[inline] + pub fn txact(&self) -> TXACTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXACTR { bits } + } + #[doc = "Bit 11 - Command transfer in progress"] + #[inline] + pub fn cmdact(&self) -> CMDACTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDACTR { bits } + } + #[doc = "Bit 10 - Data block sent/received (CRC check passed)"] + #[inline] + pub fn dbckend(&self) -> DBCKENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DBCKENDR { bits } + } + #[doc = "Bit 9 - Start bit not detected on all data signals in wide bus mode"] + #[inline] + pub fn stbiterr(&self) -> STBITERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + STBITERRR { bits } + } + #[doc = "Bit 8 - Data end (data counter, SDIDCOUNT, is zero)"] + #[inline] + pub fn dataend(&self) -> DATAENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DATAENDR { bits } + } + #[doc = "Bit 7 - Command sent (no response required)"] + #[inline] + pub fn cmdsent(&self) -> CMDSENTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDSENTR { bits } + } + #[doc = "Bit 6 - Command response received (CRC check passed)"] + #[inline] + pub fn cmdrend(&self) -> CMDRENDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMDRENDR { bits } + } + #[doc = "Bit 5 - Received FIFO overrun error"] + #[inline] + pub fn rxoverr(&self) -> RXOVERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXOVERRR { bits } + } + #[doc = "Bit 4 - Transmit FIFO underrun error"] + #[inline] + pub fn txunderr(&self) -> TXUNDERRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXUNDERRR { bits } + } + #[doc = "Bit 3 - Data timeout"] + #[inline] + pub fn dtimeout(&self) -> DTIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DTIMEOUTR { bits } + } + #[doc = "Bit 2 - Command response timeout"] + #[inline] + pub fn ctimeout(&self) -> CTIMEOUTR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTIMEOUTR { bits } + } + #[doc = "Bit 1 - Data block sent/received (CRC check failed)"] + #[inline] + pub fn dcrcfail(&self) -> DCRCFAILR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DCRCFAILR { bits } + } + #[doc = "Bit 0 - Command response received (CRC check failed)"] + #[inline] + pub fn ccrcfail(&self) -> CCRCFAILR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCRCFAILR { bits } + } +} diff --git a/src/syscfg/cmpcr/mod.rs b/src/syscfg/cmpcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3f6ea78eeced3d17eae0274406a4bfe5f048a145 --- /dev/null +++ b/src/syscfg/cmpcr/mod.rs @@ -0,0 +1,82 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +impl super::CMPCR { + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } +} +#[doc = r" Value of the field"] +pub struct READYR { + bits: bool, +} +impl READYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMP_PDR { + bits: bool, +} +impl CMP_PDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 8 - READY"] + #[inline] + pub fn ready(&self) -> READYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + READYR { bits } + } + #[doc = "Bit 0 - Compensation cell power-down"] + #[inline] + pub fn cmp_pd(&self) -> CMP_PDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CMP_PDR { bits } + } +} diff --git a/src/syscfg/exticr1/mod.rs b/src/syscfg/exticr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..344b5b53bf4b6777c4209239b29f00b2ae98c425 --- /dev/null +++ b/src/syscfg/exticr1/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EXTICR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EXTI3R { + bits: u8, +} +impl EXTI3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI2R { + bits: u8, +} +impl EXTI2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI1R { + bits: u8, +} +impl EXTI1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI0R { + bits: u8, +} +impl EXTI0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EXTI3W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI2W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI1W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI0W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI0W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti3(&self) -> EXTI3R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI3R { bits } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti2(&self) -> EXTI2R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI2R { bits } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti1(&self) -> EXTI1R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI1R { bits } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti0(&self) -> EXTI0R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI0R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti3(&mut self) -> _EXTI3W { + _EXTI3W { w: self } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti2(&mut self) -> _EXTI2W { + _EXTI2W { w: self } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti1(&mut self) -> _EXTI1W { + _EXTI1W { w: self } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 0 to 3)"] + #[inline] + pub fn exti0(&mut self) -> _EXTI0W { + _EXTI0W { w: self } + } +} diff --git a/src/syscfg/exticr2/mod.rs b/src/syscfg/exticr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..255dd2d78cd3b83fcc0b5d916d5cd33db3702dbc --- /dev/null +++ b/src/syscfg/exticr2/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EXTICR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EXTI7R { + bits: u8, +} +impl EXTI7R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI6R { + bits: u8, +} +impl EXTI6R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI5R { + bits: u8, +} +impl EXTI5R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI4R { + bits: u8, +} +impl EXTI4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EXTI7W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI7W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI6W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI6W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI5W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI5W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI4W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti7(&self) -> EXTI7R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI7R { bits } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti6(&self) -> EXTI6R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI6R { bits } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti5(&self) -> EXTI5R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI5R { bits } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti4(&self) -> EXTI4R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti7(&mut self) -> _EXTI7W { + _EXTI7W { w: self } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti6(&mut self) -> _EXTI6W { + _EXTI6W { w: self } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti5(&mut self) -> _EXTI5W { + _EXTI5W { w: self } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"] + #[inline] + pub fn exti4(&mut self) -> _EXTI4W { + _EXTI4W { w: self } + } +} diff --git a/src/syscfg/exticr3/mod.rs b/src/syscfg/exticr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b81fd869289d02ad936e9deda3656bf037f1fc87 --- /dev/null +++ b/src/syscfg/exticr3/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EXTICR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EXTI11R { + bits: u8, +} +impl EXTI11R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI10R { + bits: u8, +} +impl EXTI10R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI9R { + bits: u8, +} +impl EXTI9R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI8R { + bits: u8, +} +impl EXTI8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EXTI11W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI11W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI10W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI10W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI9W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI9W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI8W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI8W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti11(&self) -> EXTI11R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI11R { bits } + } + #[doc = "Bits 8:11 - EXTI10"] + #[inline] + pub fn exti10(&self) -> EXTI10R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI10R { bits } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti9(&self) -> EXTI9R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI9R { bits } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti8(&self) -> EXTI8R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI8R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti11(&mut self) -> _EXTI11W { + _EXTI11W { w: self } + } + #[doc = "Bits 8:11 - EXTI10"] + #[inline] + pub fn exti10(&mut self) -> _EXTI10W { + _EXTI10W { w: self } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti9(&mut self) -> _EXTI9W { + _EXTI9W { w: self } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 8 to 11)"] + #[inline] + pub fn exti8(&mut self) -> _EXTI8W { + _EXTI8W { w: self } + } +} diff --git a/src/syscfg/exticr4/mod.rs b/src/syscfg/exticr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3b4fd18c5f557f06f5315af6a597fd8bb16a809f --- /dev/null +++ b/src/syscfg/exticr4/mod.rs @@ -0,0 +1,228 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EXTICR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EXTI15R { + bits: u8, +} +impl EXTI15R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI14R { + bits: u8, +} +impl EXTI14R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI13R { + bits: u8, +} +impl EXTI13R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct EXTI12R { + bits: u8, +} +impl EXTI12R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EXTI15W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI15W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI14W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI14W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI13W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI13W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EXTI12W<'a> { + w: &'a mut W, +} +impl<'a> _EXTI12W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti15(&self) -> EXTI15R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI15R { bits } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti14(&self) -> EXTI14R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI14R { bits } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti13(&self) -> EXTI13R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI13R { bits } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti12(&self) -> EXTI12R { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + EXTI12R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti15(&mut self) -> _EXTI15W { + _EXTI15W { w: self } + } + #[doc = "Bits 8:11 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti14(&mut self) -> _EXTI14W { + _EXTI14W { w: self } + } + #[doc = "Bits 4:7 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti13(&mut self) -> _EXTI13W { + _EXTI13W { w: self } + } + #[doc = "Bits 0:3 - EXTI x configuration (x = 12 to 15)"] + #[inline] + pub fn exti12(&mut self) -> _EXTI12W { + _EXTI12W { w: self } + } +} diff --git a/src/syscfg/i2c_bufout/mod.rs b/src/syscfg/i2c_bufout/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4ca6d3ef82e693af45829fdf2ad442e2a25f3be7 --- /dev/null +++ b/src/syscfg/i2c_bufout/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::I2C_BUFOUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct I2C4SCLR { + bits: bool, +} +impl I2C4SCLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct I2C4SDAR { + bits: bool, +} +impl I2C4SDAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _I2C4SCLW<'a> { + w: &'a mut W, +} +impl<'a> _I2C4SCLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _I2C4SDAW<'a> { + w: &'a mut W, +} +impl<'a> _I2C4SDAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - I2C4SCL"] + #[inline] + pub fn i2c4scl(&self) -> I2C4SCLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C4SCLR { bits } + } + #[doc = "Bit 1 - I2C4SDA"] + #[inline] + pub fn i2c4sda(&self) -> I2C4SDAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + I2C4SDAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - I2C4SCL"] + #[inline] + pub fn i2c4scl(&mut self) -> _I2C4SCLW { + _I2C4SCLW { w: self } + } + #[doc = "Bit 1 - I2C4SDA"] + #[inline] + pub fn i2c4sda(&mut self) -> _I2C4SDAW { + _I2C4SDAW { w: self } + } +} diff --git a/src/syscfg/memrm/mod.rs b/src/syscfg/memrm/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b55207d7a8cea4e070d8d2595bc5c874e99f1f9c --- /dev/null +++ b/src/syscfg/memrm/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::MEMRM { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MEM_MODER { + bits: u8, +} +impl MEM_MODER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MEM_MODEW<'a> { + w: &'a mut W, +} +impl<'a> _MEM_MODEW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - MEM_MODE"] + #[inline] + pub fn mem_mode(&self) -> MEM_MODER { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MEM_MODER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - MEM_MODE"] + #[inline] + pub fn mem_mode(&mut self) -> _MEM_MODEW { + _MEM_MODEW { w: self } + } +} diff --git a/src/syscfg/mod.rs b/src/syscfg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4ae3bb328dca08ca8e0bc2c0c95b826ec978cdf2 --- /dev/null +++ b/src/syscfg/mod.rs @@ -0,0 +1,70 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - memory remap register"] + pub memrm: MEMRM, + #[doc = "0x04 - peripheral mode configuration register"] + pub pmc: PMC, + #[doc = "0x08 - external interrupt configuration register 1"] + pub exticr1: EXTICR1, + #[doc = "0x0c - external interrupt configuration register 2"] + pub exticr2: EXTICR2, + #[doc = "0x10 - external interrupt configuration register 3"] + pub exticr3: EXTICR3, + #[doc = "0x14 - external interrupt configuration register 4"] + pub exticr4: EXTICR4, + _reserved0: [u8; 8usize], + #[doc = "0x20 - Compensation cell control register"] + pub cmpcr: CMPCR, + _reserved1: [u8; 8usize], + #[doc = "0x2c - I2C_BUFOUT"] + pub i2c_bufout: I2C_BUFOUT, +} +#[doc = "memory remap register"] +pub struct MEMRM { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "memory remap register"] +pub mod memrm; +#[doc = "peripheral mode configuration register"] +pub struct PMC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "peripheral mode configuration register"] +pub mod pmc; +#[doc = "external interrupt configuration register 1"] +pub struct EXTICR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "external interrupt configuration register 1"] +pub mod exticr1; +#[doc = "external interrupt configuration register 2"] +pub struct EXTICR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "external interrupt configuration register 2"] +pub mod exticr2; +#[doc = "external interrupt configuration register 3"] +pub struct EXTICR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "external interrupt configuration register 3"] +pub mod exticr3; +#[doc = "external interrupt configuration register 4"] +pub struct EXTICR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "external interrupt configuration register 4"] +pub mod exticr4; +#[doc = "Compensation cell control register"] +pub struct CMPCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Compensation cell control register"] +pub mod cmpcr; +#[doc = "I2C_BUFOUT"] +pub struct I2C_BUFOUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "I2C_BUFOUT"] +pub mod i2c_bufout; diff --git a/src/syscfg/pmc/mod.rs b/src/syscfg/pmc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e7d6d211596b1fa968905562bc7cc7777fea1a1 --- /dev/null +++ b/src/syscfg/pmc/mod.rs @@ -0,0 +1,123 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PMC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ADC1DC2R { + bits: bool, +} +impl ADC1DC2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ADC1DC2W<'a> { + w: &'a mut W, +} +impl<'a> _ADC1DC2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 16 - ADC1DC2"] + #[inline] + pub fn adc1dc2(&self) -> ADC1DC2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ADC1DC2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 16 - ADC1DC2"] + #[inline] + pub fn adc1dc2(&mut self) -> _ADC1DC2W { + _ADC1DC2W { w: self } + } +} diff --git a/src/tim1/arr/mod.rs b/src/tim1/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim1/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim1/bdtr/mod.rs b/src/tim1/bdtr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ac668aa72a84d1731fa5e55558fb18d26b02b6fa --- /dev/null +++ b/src/tim1/bdtr/mod.rs @@ -0,0 +1,500 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BDTR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MOER { + bits: bool, +} +impl MOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct AOER { + bits: bool, +} +impl AOER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BKPR { + bits: bool, +} +impl BKPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BKER { + bits: bool, +} +impl BKER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OSSRR { + bits: bool, +} +impl OSSRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OSSIR { + bits: bool, +} +impl OSSIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LOCKR { + bits: u8, +} +impl LOCKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DTGR { + bits: u8, +} +impl DTGR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MOEW<'a> { + w: &'a mut W, +} +impl<'a> _MOEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _AOEW<'a> { + w: &'a mut W, +} +impl<'a> _AOEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKPW<'a> { + w: &'a mut W, +} +impl<'a> _BKPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BKEW<'a> { + w: &'a mut W, +} +impl<'a> _BKEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSSRW<'a> { + w: &'a mut W, +} +impl<'a> _OSSRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OSSIW<'a> { + w: &'a mut W, +} +impl<'a> _OSSIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LOCKW<'a> { + w: &'a mut W, +} +impl<'a> _LOCKW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DTGW<'a> { + w: &'a mut W, +} +impl<'a> _DTGW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Main output enable"] + #[inline] + pub fn moe(&self) -> MOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MOER { bits } + } + #[doc = "Bit 14 - Automatic output enable"] + #[inline] + pub fn aoe(&self) -> AOER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + AOER { bits } + } + #[doc = "Bit 13 - Break polarity"] + #[inline] + pub fn bkp(&self) -> BKPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BKPR { bits } + } + #[doc = "Bit 12 - Break enable"] + #[inline] + pub fn bke(&self) -> BKER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BKER { bits } + } + #[doc = "Bit 11 - Off-state selection for Run mode"] + #[inline] + pub fn ossr(&self) -> OSSRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OSSRR { bits } + } + #[doc = "Bit 10 - Off-state selection for Idle mode"] + #[inline] + pub fn ossi(&self) -> OSSIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OSSIR { bits } + } + #[doc = "Bits 8:9 - Lock configuration"] + #[inline] + pub fn lock(&self) -> LOCKR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + LOCKR { bits } + } + #[doc = "Bits 0:7 - Dead-time generator setup"] + #[inline] + pub fn dtg(&self) -> DTGR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DTGR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Main output enable"] + #[inline] + pub fn moe(&mut self) -> _MOEW { + _MOEW { w: self } + } + #[doc = "Bit 14 - Automatic output enable"] + #[inline] + pub fn aoe(&mut self) -> _AOEW { + _AOEW { w: self } + } + #[doc = "Bit 13 - Break polarity"] + #[inline] + pub fn bkp(&mut self) -> _BKPW { + _BKPW { w: self } + } + #[doc = "Bit 12 - Break enable"] + #[inline] + pub fn bke(&mut self) -> _BKEW { + _BKEW { w: self } + } + #[doc = "Bit 11 - Off-state selection for Run mode"] + #[inline] + pub fn ossr(&mut self) -> _OSSRW { + _OSSRW { w: self } + } + #[doc = "Bit 10 - Off-state selection for Idle mode"] + #[inline] + pub fn ossi(&mut self) -> _OSSIW { + _OSSIW { w: self } + } + #[doc = "Bits 8:9 - Lock configuration"] + #[inline] + pub fn lock(&mut self) -> _LOCKW { + _LOCKW { w: self } + } + #[doc = "Bits 0:7 - Dead-time generator setup"] + #[inline] + pub fn dtg(&mut self) -> _DTGW { + _DTGW { w: self } + } +} diff --git a/src/tim1/ccer/mod.rs b/src/tim1/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ac81f86266676b27bdaefb035ae08ade657b1c22 --- /dev/null +++ b/src/tim1/ccer/mod.rs @@ -0,0 +1,890 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4PR { + bits: bool, +} +impl CC4PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4ER { + bits: bool, +} +impl CC4ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3NPR { + bits: bool, +} +impl CC3NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3NER { + bits: bool, +} +impl CC3NER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3PR { + bits: bool, +} +impl CC3PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3ER { + bits: bool, +} +impl CC3ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2NER { + bits: bool, +} +impl CC2NER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NER { + bits: bool, +} +impl CC1NER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4PW<'a> { + w: &'a mut W, +} +impl<'a> _CC4PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4EW<'a> { + w: &'a mut W, +} +impl<'a> _CC4EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC3NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3NEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3NEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3PW<'a> { + w: &'a mut W, +} +impl<'a> _CC3PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3EW<'a> { + w: &'a mut W, +} +impl<'a> _CC3EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2NEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&self) -> CC4PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4PR { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&self) -> CC4ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4ER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&self) -> CC3NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3NPR { bits } + } + #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"] + #[inline] + pub fn cc3ne(&self) -> CC3NER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3NER { bits } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&self) -> CC3PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3PR { bits } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&self) -> CC3ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3ER { bits } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"] + #[inline] + pub fn cc2ne(&self) -> CC2NER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NER { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] + #[inline] + pub fn cc1ne(&self) -> CC1NER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&mut self) -> _CC4PW { + _CC4PW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&mut self) -> _CC4EW { + _CC4EW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&mut self) -> _CC3NPW { + _CC3NPW { w: self } + } + #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"] + #[inline] + pub fn cc3ne(&mut self) -> _CC3NEW { + _CC3NEW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&mut self) -> _CC3PW { + _CC3PW { w: self } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&mut self) -> _CC3EW { + _CC3EW { w: self } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"] + #[inline] + pub fn cc2ne(&mut self) -> _CC2NEW { + _CC2NEW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] + #[inline] + pub fn cc1ne(&mut self) -> _CC1NEW { + _CC1NEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim1/ccmr1_input/mod.rs b/src/tim1/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eb9746ad82aed1e898e939c332b4cb8d7cf2b665 --- /dev/null +++ b/src/tim1/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PCSR { + bits: u8, +} +impl IC2PCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PCSW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&self) -> IC2PCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PCSR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&mut self) -> _IC2PCSW { + _IC2PCSW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim1/ccmr1_output/mod.rs b/src/tim1/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2fe64fee3ba68d49a3c49492e32e995ece345717 --- /dev/null +++ b/src/tim1/ccmr1_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2CER { + bits: bool, +} +impl OC2CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1CER { + bits: bool, +} +impl OC1CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Output Compare 2 clear enable"] + #[inline] + pub fn oc2ce(&self) -> OC2CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2CER { bits } + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bit 7 - Output Compare 1 clear enable"] + #[inline] + pub fn oc1ce(&self) -> OC1CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1CER { bits } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Output Compare 2 clear enable"] + #[inline] + pub fn oc2ce(&mut self) -> _OC2CEW { + _OC2CEW { w: self } + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bit 7 - Output Compare 1 clear enable"] + #[inline] + pub fn oc1ce(&mut self) -> _OC1CEW { + _OC1CEW { w: self } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim1/ccmr2_input/mod.rs b/src/tim1/ccmr2_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d3fbf95d0c5bba2ec6b45a3b769c93e39e7b3e3 --- /dev/null +++ b/src/tim1/ccmr2_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC4FR { + bits: u8, +} +impl IC4FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC4PSCR { + bits: u8, +} +impl IC4PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3FR { + bits: u8, +} +impl IC3FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3PSCR { + bits: u8, +} +impl IC3PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC4FW<'a> { + w: &'a mut W, +} +impl<'a> _IC4FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC4PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC4PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3FW<'a> { + w: &'a mut W, +} +impl<'a> _IC3FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC3PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&self) -> IC4FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4FR { bits } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&self) -> IC4PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4PSCR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&self) -> IC3FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3FR { bits } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&self) -> IC3PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&mut self) -> _IC4FW { + _IC4FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&mut self) -> _IC4PSCW { + _IC4PSCW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&mut self) -> _IC3FW { + _IC3FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&mut self) -> _IC3PSCW { + _IC3PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim1/ccmr2_output/mod.rs b/src/tim1/ccmr2_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1575cde3428f430bc2626a919b1bf980c08fa861 --- /dev/null +++ b/src/tim1/ccmr2_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC4CER { + bits: bool, +} +impl OC4CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4MR { + bits: u8, +} +impl OC4MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC4PER { + bits: bool, +} +impl OC4PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4FER { + bits: bool, +} +impl OC4FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3CER { + bits: bool, +} +impl OC3CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3MR { + bits: u8, +} +impl OC3MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3PER { + bits: bool, +} +impl OC3PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3FER { + bits: bool, +} +impl OC3FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC4CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4MW<'a> { + w: &'a mut W, +} +impl<'a> _OC4MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3MW<'a> { + w: &'a mut W, +} +impl<'a> _OC3MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Output compare 4 clear enable"] + #[inline] + pub fn oc4ce(&self) -> OC4CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4CER { bits } + } + #[doc = "Bits 12:14 - Output compare 4 mode"] + #[inline] + pub fn oc4m(&self) -> OC4MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC4MR { bits } + } + #[doc = "Bit 11 - Output compare 4 preload enable"] + #[inline] + pub fn oc4pe(&self) -> OC4PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4PER { bits } + } + #[doc = "Bit 10 - Output compare 4 fast enable"] + #[inline] + pub fn oc4fe(&self) -> OC4FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4FER { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bit 7 - Output compare 3 clear enable"] + #[inline] + pub fn oc3ce(&self) -> OC3CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3CER { bits } + } + #[doc = "Bits 4:6 - Output compare 3 mode"] + #[inline] + pub fn oc3m(&self) -> OC3MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC3MR { bits } + } + #[doc = "Bit 3 - Output compare 3 preload enable"] + #[inline] + pub fn oc3pe(&self) -> OC3PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3PER { bits } + } + #[doc = "Bit 2 - Output compare 3 fast enable"] + #[inline] + pub fn oc3fe(&self) -> OC3FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 3 selection"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Output compare 4 clear enable"] + #[inline] + pub fn oc4ce(&mut self) -> _OC4CEW { + _OC4CEW { w: self } + } + #[doc = "Bits 12:14 - Output compare 4 mode"] + #[inline] + pub fn oc4m(&mut self) -> _OC4MW { + _OC4MW { w: self } + } + #[doc = "Bit 11 - Output compare 4 preload enable"] + #[inline] + pub fn oc4pe(&mut self) -> _OC4PEW { + _OC4PEW { w: self } + } + #[doc = "Bit 10 - Output compare 4 fast enable"] + #[inline] + pub fn oc4fe(&mut self) -> _OC4FEW { + _OC4FEW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bit 7 - Output compare 3 clear enable"] + #[inline] + pub fn oc3ce(&mut self) -> _OC3CEW { + _OC3CEW { w: self } + } + #[doc = "Bits 4:6 - Output compare 3 mode"] + #[inline] + pub fn oc3m(&mut self) -> _OC3MW { + _OC3MW { w: self } + } + #[doc = "Bit 3 - Output compare 3 preload enable"] + #[inline] + pub fn oc3pe(&mut self) -> _OC3PEW { + _OC3PEW { w: self } + } + #[doc = "Bit 2 - Output compare 3 fast enable"] + #[inline] + pub fn oc3fe(&mut self) -> _OC3FEW { + _OC3FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 3 selection"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim1/ccr1/mod.rs b/src/tim1/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim1/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim1/ccr2/mod.rs b/src/tim1/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..869f0bd5a0fa31bc5a322cd76f260653eb9c8ca8 --- /dev/null +++ b/src/tim1/ccr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2R { + bits: u16, +} +impl CCR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2W<'a> { + w: &'a mut W, +} +impl<'a> _CCR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&self) -> CCR2R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&mut self) -> _CCR2W { + _CCR2W { w: self } + } +} diff --git a/src/tim1/ccr3/mod.rs b/src/tim1/ccr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9d26371a174bd0e9e74ba68d85193df28d19a594 --- /dev/null +++ b/src/tim1/ccr3/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR3R { + bits: u16, +} +impl CCR3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR3W<'a> { + w: &'a mut W, +} +impl<'a> _CCR3W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare value"] + #[inline] + pub fn ccr3(&self) -> CCR3R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare value"] + #[inline] + pub fn ccr3(&mut self) -> _CCR3W { + _CCR3W { w: self } + } +} diff --git a/src/tim1/ccr4/mod.rs b/src/tim1/ccr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fc796fc8cf4b1c206a41d9c4e596cd2fe3cc0d3b --- /dev/null +++ b/src/tim1/ccr4/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR4R { + bits: u16, +} +impl CCR4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR4W<'a> { + w: &'a mut W, +} +impl<'a> _CCR4W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare value"] + #[inline] + pub fn ccr4(&self) -> CCR4R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare value"] + #[inline] + pub fn ccr4(&mut self) -> _CCR4W { + _CCR4W { w: self } + } +} diff --git a/src/tim1/cnt/mod.rs b/src/tim1/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim1/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim1/cr1/mod.rs b/src/tim1/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..164561984a4a4c53f7c4af0afd22d5e56103f974 --- /dev/null +++ b/src/tim1/cr1/mod.rs @@ -0,0 +1,500 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMSR { + bits: u8, +} +impl CMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: bool, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMSW<'a> { + w: &'a mut W, +} +impl<'a> _CMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&self) -> CMSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CMSR { bits } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DIRR { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&mut self) -> _CMSW { + _CMSW { w: self } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim1/cr2/mod.rs b/src/tim1/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0d04b1552a2839386a35f8f4dee7acdefbd1994f --- /dev/null +++ b/src/tim1/cr2/mod.rs @@ -0,0 +1,754 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OIS4R { + bits: bool, +} +impl OIS4R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS3NR { + bits: bool, +} +impl OIS3NR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS3R { + bits: bool, +} +impl OIS3R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS2NR { + bits: bool, +} +impl OIS2NR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS2R { + bits: bool, +} +impl OIS2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS1NR { + bits: bool, +} +impl OIS1NR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OIS1R { + bits: bool, +} +impl OIS1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TI1SR { + bits: bool, +} +impl TI1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCDSR { + bits: bool, +} +impl CCDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCUSR { + bits: bool, +} +impl CCUSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CCPCR { + bits: bool, +} +impl CCPCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OIS4W<'a> { + w: &'a mut W, +} +impl<'a> _OIS4W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS3NW<'a> { + w: &'a mut W, +} +impl<'a> _OIS3NW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS3W<'a> { + w: &'a mut W, +} +impl<'a> _OIS3W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS2NW<'a> { + w: &'a mut W, +} +impl<'a> _OIS2NW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS2W<'a> { + w: &'a mut W, +} +impl<'a> _OIS2W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS1NW<'a> { + w: &'a mut W, +} +impl<'a> _OIS1NW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OIS1W<'a> { + w: &'a mut W, +} +impl<'a> _OIS1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TI1SW<'a> { + w: &'a mut W, +} +impl<'a> _TI1SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCDSW<'a> { + w: &'a mut W, +} +impl<'a> _CCDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCUSW<'a> { + w: &'a mut W, +} +impl<'a> _CCUSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCPCW<'a> { + w: &'a mut W, +} +impl<'a> _CCPCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - Output Idle state 4"] + #[inline] + pub fn ois4(&self) -> OIS4R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS4R { bits } + } + #[doc = "Bit 13 - Output Idle state 3"] + #[inline] + pub fn ois3n(&self) -> OIS3NR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS3NR { bits } + } + #[doc = "Bit 12 - Output Idle state 3"] + #[inline] + pub fn ois3(&self) -> OIS3R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS3R { bits } + } + #[doc = "Bit 11 - Output Idle state 2"] + #[inline] + pub fn ois2n(&self) -> OIS2NR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS2NR { bits } + } + #[doc = "Bit 10 - Output Idle state 2"] + #[inline] + pub fn ois2(&self) -> OIS2R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS2R { bits } + } + #[doc = "Bit 9 - Output Idle state 1"] + #[inline] + pub fn ois1n(&self) -> OIS1NR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS1NR { bits } + } + #[doc = "Bit 8 - Output Idle state 1"] + #[inline] + pub fn ois1(&self) -> OIS1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OIS1R { bits } + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&self) -> TI1SR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TI1SR { bits } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&self) -> CCDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCDSR { bits } + } + #[doc = "Bit 2 - Capture/compare control update selection"] + #[inline] + pub fn ccus(&self) -> CCUSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCUSR { bits } + } + #[doc = "Bit 0 - Capture/compare preloaded control"] + #[inline] + pub fn ccpc(&self) -> CCPCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCPCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - Output Idle state 4"] + #[inline] + pub fn ois4(&mut self) -> _OIS4W { + _OIS4W { w: self } + } + #[doc = "Bit 13 - Output Idle state 3"] + #[inline] + pub fn ois3n(&mut self) -> _OIS3NW { + _OIS3NW { w: self } + } + #[doc = "Bit 12 - Output Idle state 3"] + #[inline] + pub fn ois3(&mut self) -> _OIS3W { + _OIS3W { w: self } + } + #[doc = "Bit 11 - Output Idle state 2"] + #[inline] + pub fn ois2n(&mut self) -> _OIS2NW { + _OIS2NW { w: self } + } + #[doc = "Bit 10 - Output Idle state 2"] + #[inline] + pub fn ois2(&mut self) -> _OIS2W { + _OIS2W { w: self } + } + #[doc = "Bit 9 - Output Idle state 1"] + #[inline] + pub fn ois1n(&mut self) -> _OIS1NW { + _OIS1NW { w: self } + } + #[doc = "Bit 8 - Output Idle state 1"] + #[inline] + pub fn ois1(&mut self) -> _OIS1W { + _OIS1W { w: self } + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&mut self) -> _TI1SW { + _TI1SW { w: self } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&mut self) -> _CCDSW { + _CCDSW { w: self } + } + #[doc = "Bit 2 - Capture/compare control update selection"] + #[inline] + pub fn ccus(&mut self) -> _CCUSW { + _CCUSW { w: self } + } + #[doc = "Bit 0 - Capture/compare preloaded control"] + #[inline] + pub fn ccpc(&mut self) -> _CCPCW { + _CCPCW { w: self } + } +} diff --git a/src/tim1/dcr/mod.rs b/src/tim1/dcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e448383dd86194bcc6682ddee18ee7115780a78 --- /dev/null +++ b/src/tim1/dcr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBLR { + bits: u8, +} +impl DBLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DBAR { + bits: u8, +} +impl DBAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DBLW<'a> { + w: &'a mut W, +} +impl<'a> _DBLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBAW<'a> { + w: &'a mut W, +} +impl<'a> _DBAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&self) -> DBLR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBLR { bits } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&self) -> DBAR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&mut self) -> _DBLW { + _DBLW { w: self } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&mut self) -> _DBAW { + _DBAW { w: self } + } +} diff --git a/src/tim1/dier/mod.rs b/src/tim1/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eba4cc56410619870e1b9d4f89518683a62d5562 --- /dev/null +++ b/src/tim1/dier/mod.rs @@ -0,0 +1,949 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TDER { + bits: bool, +} +impl TDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct COMDER { + bits: bool, +} +impl COMDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4DER { + bits: bool, +} +impl CC4DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3DER { + bits: bool, +} +impl CC3DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2DER { + bits: bool, +} +impl CC2DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1DER { + bits: bool, +} +impl CC1DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDER { + bits: bool, +} +impl UDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BIER { + bits: bool, +} +impl BIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct COMIER { + bits: bool, +} +impl COMIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IER { + bits: bool, +} +impl CC4IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IER { + bits: bool, +} +impl CC3IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TDEW<'a> { + w: &'a mut W, +} +impl<'a> _TDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COMDEW<'a> { + w: &'a mut W, +} +impl<'a> _COMDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDEW<'a> { + w: &'a mut W, +} +impl<'a> _UDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BIEW<'a> { + w: &'a mut W, +} +impl<'a> _BIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COMIEW<'a> { + w: &'a mut W, +} +impl<'a> _COMIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&self) -> TDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TDER { bits } + } + #[doc = "Bit 13 - COM DMA request enable"] + #[inline] + pub fn comde(&self) -> COMDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COMDER { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&self) -> CC4DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4DER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&self) -> CC3DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3DER { bits } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&self) -> CC2DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2DER { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&self) -> CC1DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1DER { bits } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&self) -> UDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDER { bits } + } + #[doc = "Bit 7 - Break interrupt enable"] + #[inline] + pub fn bie(&self) -> BIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BIER { bits } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 5 - COM interrupt enable"] + #[inline] + pub fn comie(&self) -> COMIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COMIER { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&self) -> CC4IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IER { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&self) -> CC3IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&mut self) -> _TDEW { + _TDEW { w: self } + } + #[doc = "Bit 13 - COM DMA request enable"] + #[inline] + pub fn comde(&mut self) -> _COMDEW { + _COMDEW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&mut self) -> _CC4DEW { + _CC4DEW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&mut self) -> _CC3DEW { + _CC3DEW { w: self } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&mut self) -> _CC2DEW { + _CC2DEW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&mut self) -> _CC1DEW { + _CC1DEW { w: self } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&mut self) -> _UDEW { + _UDEW { w: self } + } + #[doc = "Bit 7 - Break interrupt enable"] + #[inline] + pub fn bie(&mut self) -> _BIEW { + _BIEW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 5 - COM interrupt enable"] + #[inline] + pub fn comie(&mut self) -> _COMIEW { + _COMIEW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&mut self) -> _CC4IEW { + _CC4IEW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&mut self) -> _CC3IEW { + _CC3IEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim1/dmar/mod.rs b/src/tim1/dmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61a7e568c1218c1d06c02138357526446d894e0a --- /dev/null +++ b/src/tim1/dmar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMABR { + bits: u16, +} +impl DMABR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DMABW<'a> { + w: &'a mut W, +} +impl<'a> _DMABW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&self) -> DMABR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DMABR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&mut self) -> _DMABW { + _DMABW { w: self } + } +} diff --git a/src/tim1/egr/mod.rs b/src/tim1/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d0d84571869827d5ca5066a09432245ac3490a6a --- /dev/null +++ b/src/tim1/egr/mod.rs @@ -0,0 +1,253 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _BGW<'a> { + w: &'a mut W, +} +impl<'a> _BGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COMGW<'a> { + w: &'a mut W, +} +impl<'a> _COMGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4GW<'a> { + w: &'a mut W, +} +impl<'a> _CC4GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3GW<'a> { + w: &'a mut W, +} +impl<'a> _CC3GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Break generation"] + #[inline] + pub fn bg(&mut self) -> _BGW { + _BGW { w: self } + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 5 - Capture/Compare control update generation"] + #[inline] + pub fn comg(&mut self) -> _COMGW { + _COMGW { w: self } + } + #[doc = "Bit 4 - Capture/compare 4 generation"] + #[inline] + pub fn cc4g(&mut self) -> _CC4GW { + _CC4GW { w: self } + } + #[doc = "Bit 3 - Capture/compare 3 generation"] + #[inline] + pub fn cc3g(&mut self) -> _CC3GW { + _CC3GW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim1/mod.rs b/src/tim1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8aba7b952090beaf0f31b5ab2238957cc0c481b9 --- /dev/null +++ b/src/tim1/mod.rs @@ -0,0 +1,176 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + #[doc = "0x1c - capture/compare mode register 2 (output mode)"] + pub ccmr2_output: CCMR2_OUTPUT, + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + #[doc = "0x30 - repetition counter register"] + pub rcr: RCR, + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, + #[doc = "0x3c - capture/compare register 3"] + pub ccr3: CCR3, + #[doc = "0x40 - capture/compare register 4"] + pub ccr4: CCR4, + #[doc = "0x44 - break and dead-time register"] + pub bdtr: BDTR, + #[doc = "0x48 - DMA control register"] + pub dcr: DCR, + #[doc = "0x4c - DMA address for full transfer"] + pub dmar: DMAR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare mode register 2 (output mode)"] +pub struct CCMR2_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (output mode)"] +pub mod ccmr2_output; +#[doc = "capture/compare mode register 2 (input mode)"] +pub struct CCMR2_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (input mode)"] +pub mod ccmr2_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; +#[doc = "capture/compare register 3"] +pub struct CCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 3"] +pub mod ccr3; +#[doc = "capture/compare register 4"] +pub struct CCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 4"] +pub mod ccr4; +#[doc = "DMA control register"] +pub struct DCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA control register"] +pub mod dcr; +#[doc = "DMA address for full transfer"] +pub struct DMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA address for full transfer"] +pub mod dmar; +#[doc = "repetition counter register"] +pub struct RCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "repetition counter register"] +pub mod rcr; +#[doc = "break and dead-time register"] +pub struct BDTR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "break and dead-time register"] +pub mod bdtr; diff --git a/src/tim1/psc/mod.rs b/src/tim1/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim1/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim1/rcr/mod.rs b/src/tim1/rcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d1e0e40e99dde6c03f2717466abcf3912e9e6f72 --- /dev/null +++ b/src/tim1/rcr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::RCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct REPR { + bits: u8, +} +impl REPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _REPW<'a> { + w: &'a mut W, +} +impl<'a> _REPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:7 - Repetition counter value"] + #[inline] + pub fn rep(&self) -> REPR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + REPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:7 - Repetition counter value"] + #[inline] + pub fn rep(&mut self) -> _REPW { + _REPW { w: self } + } +} diff --git a/src/tim1/smcr/mod.rs b/src/tim1/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3a864425c88ed3260d3d674aa86079e54f90bf10 --- /dev/null +++ b/src/tim1/smcr/mod.rs @@ -0,0 +1,405 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ETPR { + bits: bool, +} +impl ETPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ECER { + bits: bool, +} +impl ECER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ETPSR { + bits: u8, +} +impl ETPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ETFR { + bits: u8, +} +impl ETFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ETPW<'a> { + w: &'a mut W, +} +impl<'a> _ETPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECEW<'a> { + w: &'a mut W, +} +impl<'a> _ECEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETPSW<'a> { + w: &'a mut W, +} +impl<'a> _ETPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETFW<'a> { + w: &'a mut W, +} +impl<'a> _ETFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&self) -> ETPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ETPR { bits } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&self) -> ECER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECER { bits } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&self) -> ETPSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETPSR { bits } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&self) -> ETFR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETFR { bits } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&mut self) -> _ETPW { + _ETPW { w: self } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&mut self) -> _ECEW { + _ECEW { w: self } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&mut self) -> _ETPSW { + _ETPSW { w: self } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&mut self) -> _ETFW { + _ETFW { w: self } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim1/sr/mod.rs b/src/tim1/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..27940ce3376976d4af6ed84a498a14e670e4d245 --- /dev/null +++ b/src/tim1/sr/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4OFR { + bits: bool, +} +impl CC4OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3OFR { + bits: bool, +} +impl CC3OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct BIFR { + bits: bool, +} +impl BIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct COMIFR { + bits: bool, +} +impl COMIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IFR { + bits: bool, +} +impl CC4IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IFR { + bits: bool, +} +impl CC3IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _BIFW<'a> { + w: &'a mut W, +} +impl<'a> _BIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _COMIFW<'a> { + w: &'a mut W, +} +impl<'a> _COMIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&self) -> CC4OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4OFR { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&self) -> CC3OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3OFR { bits } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 7 - Break interrupt flag"] + #[inline] + pub fn bif(&self) -> BIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + BIFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 5 - COM interrupt flag"] + #[inline] + pub fn comif(&self) -> COMIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + COMIFR { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&self) -> CC4IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IFR { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&self) -> CC3IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&mut self) -> _CC4OFW { + _CC4OFW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&mut self) -> _CC3OFW { + _CC3OFW { w: self } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 7 - Break interrupt flag"] + #[inline] + pub fn bif(&mut self) -> _BIFW { + _BIFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 5 - COM interrupt flag"] + #[inline] + pub fn comif(&mut self) -> _COMIFW { + _COMIFW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&mut self) -> _CC4IFW { + _CC4IFW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&mut self) -> _CC3IFW { + _CC3IFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim10/arr/mod.rs b/src/tim10/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim10/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim10/ccer/mod.rs b/src/tim10/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..beecad1d06f5d1511d68554b130cc8b486f60d1b --- /dev/null +++ b/src/tim10/ccer/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim10/ccmr1_input/mod.rs b/src/tim10/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6f6efa4f7157e846cbabed31615fceef5921cf74 --- /dev/null +++ b/src/tim10/ccmr1_input/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim10/ccmr1_output/mod.rs b/src/tim10/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c01ad9111b09e0b417b4a2151d8f93a5a4d6b31f --- /dev/null +++ b/src/tim10/ccmr1_output/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim10/ccr1/mod.rs b/src/tim10/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim10/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim10/cnt/mod.rs b/src/tim10/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim10/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim10/cr1/mod.rs b/src/tim10/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19a878be6da04cb9a7ced91cdb0a748db51b06bf --- /dev/null +++ b/src/tim10/cr1/mod.rs @@ -0,0 +1,341 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim10/dier/mod.rs b/src/tim10/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..afa75c5289f2444b586d0daddece1ffa09cc7c44 --- /dev/null +++ b/src/tim10/dier/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim10/egr/mod.rs b/src/tim10/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6fb925661cd018f9ba597c1bcaa120c1c2dbae0 --- /dev/null +++ b/src/tim10/egr/mod.rs @@ -0,0 +1,85 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim10/mod.rs b/src/tim10/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0c1844ca7e3b2ae2223db5b8aaf1f2f517e327a2 --- /dev/null +++ b/src/tim10/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + _reserved0: [u8; 8usize], + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + _reserved1: [u8; 4usize], + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved2: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; diff --git a/src/tim10/psc/mod.rs b/src/tim10/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim10/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim10/sr/mod.rs b/src/tim10/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1fa02d5ae39145d76a78238c9af9597a62801c3b --- /dev/null +++ b/src/tim10/sr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim11/arr/mod.rs b/src/tim11/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim11/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim11/ccer/mod.rs b/src/tim11/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..beecad1d06f5d1511d68554b130cc8b486f60d1b --- /dev/null +++ b/src/tim11/ccer/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim11/ccmr1_input/mod.rs b/src/tim11/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6f6efa4f7157e846cbabed31615fceef5921cf74 --- /dev/null +++ b/src/tim11/ccmr1_input/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim11/ccmr1_output/mod.rs b/src/tim11/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c01ad9111b09e0b417b4a2151d8f93a5a4d6b31f --- /dev/null +++ b/src/tim11/ccmr1_output/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim11/ccr1/mod.rs b/src/tim11/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim11/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim11/cnt/mod.rs b/src/tim11/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim11/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim11/cr1/mod.rs b/src/tim11/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19a878be6da04cb9a7ced91cdb0a748db51b06bf --- /dev/null +++ b/src/tim11/cr1/mod.rs @@ -0,0 +1,341 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim11/dier/mod.rs b/src/tim11/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..afa75c5289f2444b586d0daddece1ffa09cc7c44 --- /dev/null +++ b/src/tim11/dier/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim11/egr/mod.rs b/src/tim11/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6fb925661cd018f9ba597c1bcaa120c1c2dbae0 --- /dev/null +++ b/src/tim11/egr/mod.rs @@ -0,0 +1,85 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim11/mod.rs b/src/tim11/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fed3a13f03ac23d88747a0ab28cb4530606ceec3 --- /dev/null +++ b/src/tim11/mod.rs @@ -0,0 +1,102 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + _reserved0: [u8; 8usize], + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + _reserved1: [u8; 4usize], + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved2: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + _reserved3: [u8; 24usize], + #[doc = "0x50 - option register"] + pub or: OR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "option register"] +pub struct OR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "option register"] +pub mod or; diff --git a/src/tim11/or/mod.rs b/src/tim11/or/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9fe343559116e7c06f7d753f7dc43f41b62f16a7 --- /dev/null +++ b/src/tim11/or/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct RMPR { + bits: u8, +} +impl RMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _RMPW<'a> { + w: &'a mut W, +} +impl<'a> _RMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - Input 1 remapping capability"] + #[inline] + pub fn rmp(&self) -> RMPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + RMPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - Input 1 remapping capability"] + #[inline] + pub fn rmp(&mut self) -> _RMPW { + _RMPW { w: self } + } +} diff --git a/src/tim11/psc/mod.rs b/src/tim11/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim11/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim11/sr/mod.rs b/src/tim11/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1fa02d5ae39145d76a78238c9af9597a62801c3b --- /dev/null +++ b/src/tim11/sr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim12/arr/mod.rs b/src/tim12/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim12/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim12/ccer/mod.rs b/src/tim12/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c489e741a0ea907d9c0e6eb7fc8dcb96691f90fa --- /dev/null +++ b/src/tim12/ccer/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim12/ccmr1_input/mod.rs b/src/tim12/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..84a7023a179712420d3fa5a52d63c24f29c62795 --- /dev/null +++ b/src/tim12/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PSCR { + bits: u8, +} +impl IC2PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1PSCR { + bits: u8, +} +impl IC1PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC1PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2psc(&self) -> IC2PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PSCR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:6 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn ic1psc(&self) -> IC1PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2psc(&mut self) -> _IC2PSCW { + _IC2PSCW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:6 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn ic1psc(&mut self) -> _IC1PSCW { + _IC1PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim12/ccmr1_output/mod.rs b/src/tim12/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c2eaa5569197cd3e4fc68ba73ad12636b5c7b428 --- /dev/null +++ b/src/tim12/ccmr1_output/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim12/ccr1/mod.rs b/src/tim12/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim12/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim12/ccr2/mod.rs b/src/tim12/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..869f0bd5a0fa31bc5a322cd76f260653eb9c8ca8 --- /dev/null +++ b/src/tim12/ccr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2R { + bits: u16, +} +impl CCR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2W<'a> { + w: &'a mut W, +} +impl<'a> _CCR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&self) -> CCR2R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&mut self) -> _CCR2W { + _CCR2W { w: self } + } +} diff --git a/src/tim12/cnt/mod.rs b/src/tim12/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim12/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim12/cr1/mod.rs b/src/tim12/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4d7c3931977c84874b79f366865477e9b55050b6 --- /dev/null +++ b/src/tim12/cr1/mod.rs @@ -0,0 +1,400 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim12/dier/mod.rs b/src/tim12/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1362aa66aee8b1b011ca59fbba6fc7a1a957c1b8 --- /dev/null +++ b/src/tim12/dier/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim12/egr/mod.rs b/src/tim12/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b06767684dc060a6053c0af73e0e1223c3872c64 --- /dev/null +++ b/src/tim12/egr/mod.rs @@ -0,0 +1,141 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim12/mod.rs b/src/tim12/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e6b45a7376c4bb3fb80cc8764574b3c52dc468ac --- /dev/null +++ b/src/tim12/mod.rs @@ -0,0 +1,109 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + _reserved0: [u8; 4usize], + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + _reserved1: [u8; 4usize], + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved2: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; diff --git a/src/tim12/psc/mod.rs b/src/tim12/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim12/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim12/smcr/mod.rs b/src/tim12/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..74704ba697a5627335e3f8917c32bbdc7e540a9e --- /dev/null +++ b/src/tim12/smcr/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim12/sr/mod.rs b/src/tim12/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..17340bed81054d3d2d0cd2133efa5bcd4fdda48e --- /dev/null +++ b/src/tim12/sr/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim13/arr/mod.rs b/src/tim13/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim13/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim13/ccer/mod.rs b/src/tim13/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..beecad1d06f5d1511d68554b130cc8b486f60d1b --- /dev/null +++ b/src/tim13/ccer/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim13/ccmr1_input/mod.rs b/src/tim13/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..768216a1d89de0d4d00216a0f6e7a2bd39fda9fc --- /dev/null +++ b/src/tim13/ccmr1_input/mod.rs @@ -0,0 +1,187 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1PSCR { + bits: u8, +} +impl IC1PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC1PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn ic1psc(&self) -> IC1PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn ic1psc(&mut self) -> _IC1PSCW { + _IC1PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim13/ccmr1_output/mod.rs b/src/tim13/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3258396a6553490bb0189ce83f00a7b57d1f8b2b --- /dev/null +++ b/src/tim13/ccmr1_output/mod.rs @@ -0,0 +1,264 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } + #[doc = "Bit 2 - Output compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } + #[doc = "Bit 2 - Output compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } +} diff --git a/src/tim13/ccr1/mod.rs b/src/tim13/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim13/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim13/cnt/mod.rs b/src/tim13/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim13/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim13/cr1/mod.rs b/src/tim13/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..19a878be6da04cb9a7ced91cdb0a748db51b06bf --- /dev/null +++ b/src/tim13/cr1/mod.rs @@ -0,0 +1,341 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim13/dier/mod.rs b/src/tim13/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..afa75c5289f2444b586d0daddece1ffa09cc7c44 --- /dev/null +++ b/src/tim13/dier/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim13/egr/mod.rs b/src/tim13/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b6fb925661cd018f9ba597c1bcaa120c1c2dbae0 --- /dev/null +++ b/src/tim13/egr/mod.rs @@ -0,0 +1,85 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim13/mod.rs b/src/tim13/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b59b3362d54ef73bd27f27d25d6c1b9d6198a9c9 --- /dev/null +++ b/src/tim13/mod.rs @@ -0,0 +1,93 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + _reserved0: [u8; 8usize], + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + _reserved1: [u8; 4usize], + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved2: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; diff --git a/src/tim13/psc/mod.rs b/src/tim13/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim13/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim13/sr/mod.rs b/src/tim13/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1fa02d5ae39145d76a78238c9af9597a62801c3b --- /dev/null +++ b/src/tim13/sr/mod.rs @@ -0,0 +1,241 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim2/arr/mod.rs b/src/tim2/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8118e1f3d94628be2f28b732992a94b0e334442c --- /dev/null +++ b/src/tim2/arr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARR_HR { + bits: u16, +} +impl ARR_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARR_LR { + bits: u16, +} +impl ARR_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARR_HW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARR_LW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&self) -> ARR_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_HR { bits } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&self) -> ARR_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&mut self) -> _ARR_HW { + _ARR_HW { w: self } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&mut self) -> _ARR_LW { + _ARR_LW { w: self } + } +} diff --git a/src/tim2/ccer/mod.rs b/src/tim2/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..22f09dea19adf671403a5cb24823a981d4b68d31 --- /dev/null +++ b/src/tim2/ccer/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4NPR { + bits: bool, +} +impl CC4NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4PR { + bits: bool, +} +impl CC4PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4ER { + bits: bool, +} +impl CC4ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3NPR { + bits: bool, +} +impl CC3NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3PR { + bits: bool, +} +impl CC3PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3ER { + bits: bool, +} +impl CC3ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC4NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4PW<'a> { + w: &'a mut W, +} +impl<'a> _CC4PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4EW<'a> { + w: &'a mut W, +} +impl<'a> _CC4EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC3NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3PW<'a> { + w: &'a mut W, +} +impl<'a> _CC3PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3EW<'a> { + w: &'a mut W, +} +impl<'a> _CC3EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&self) -> CC4NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4NPR { bits } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&self) -> CC4PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4PR { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&self) -> CC4ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4ER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&self) -> CC3NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3NPR { bits } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&self) -> CC3PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3PR { bits } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&self) -> CC3ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3ER { bits } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&mut self) -> _CC4NPW { + _CC4NPW { w: self } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&mut self) -> _CC4PW { + _CC4PW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&mut self) -> _CC4EW { + _CC4EW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&mut self) -> _CC3NPW { + _CC3NPW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&mut self) -> _CC3PW { + _CC3PW { w: self } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&mut self) -> _CC3EW { + _CC3EW { w: self } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim2/ccmr1_input/mod.rs b/src/tim2/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eb9746ad82aed1e898e939c332b4cb8d7cf2b665 --- /dev/null +++ b/src/tim2/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PCSR { + bits: u8, +} +impl IC2PCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PCSW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&self) -> IC2PCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PCSR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&mut self) -> _IC2PCSW { + _IC2PCSW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim2/ccmr1_output/mod.rs b/src/tim2/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f71a477d65a5f5915da6ae3dc24c069a7f92105a --- /dev/null +++ b/src/tim2/ccmr1_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2CER { + bits: bool, +} +impl OC2CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1CER { + bits: bool, +} +impl OC1CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&self) -> OC2CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2CER { bits } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&self) -> OC1CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1CER { bits } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&mut self) -> _OC2CEW { + _OC2CEW { w: self } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&mut self) -> _OC1CEW { + _OC1CEW { w: self } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim2/ccmr2_input/mod.rs b/src/tim2/ccmr2_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d3fbf95d0c5bba2ec6b45a3b769c93e39e7b3e3 --- /dev/null +++ b/src/tim2/ccmr2_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC4FR { + bits: u8, +} +impl IC4FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC4PSCR { + bits: u8, +} +impl IC4PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3FR { + bits: u8, +} +impl IC3FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3PSCR { + bits: u8, +} +impl IC3PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC4FW<'a> { + w: &'a mut W, +} +impl<'a> _IC4FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC4PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC4PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3FW<'a> { + w: &'a mut W, +} +impl<'a> _IC3FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC3PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&self) -> IC4FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4FR { bits } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&self) -> IC4PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4PSCR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&self) -> IC3FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3FR { bits } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&self) -> IC3PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&mut self) -> _IC4FW { + _IC4FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&mut self) -> _IC4PSCW { + _IC4PSCW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&mut self) -> _IC3FW { + _IC3FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&mut self) -> _IC3PSCW { + _IC3PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim2/ccmr2_output/mod.rs b/src/tim2/ccmr2_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ea5b84fb77c0bad57434df8d777a8986c7144b17 --- /dev/null +++ b/src/tim2/ccmr2_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct O24CER { + bits: bool, +} +impl O24CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4MR { + bits: u8, +} +impl OC4MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC4PER { + bits: bool, +} +impl OC4PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4FER { + bits: bool, +} +impl OC4FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3CER { + bits: bool, +} +impl OC3CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3MR { + bits: u8, +} +impl OC3MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3PER { + bits: bool, +} +impl OC3PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3FER { + bits: bool, +} +impl OC3FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _O24CEW<'a> { + w: &'a mut W, +} +impl<'a> _O24CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4MW<'a> { + w: &'a mut W, +} +impl<'a> _OC4MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3MW<'a> { + w: &'a mut W, +} +impl<'a> _OC3MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&self) -> O24CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + O24CER { bits } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&self) -> OC4MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC4MR { bits } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&self) -> OC4PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4PER { bits } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&self) -> OC4FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4FER { bits } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&self) -> OC3CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3CER { bits } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&self) -> OC3MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC3MR { bits } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&self) -> OC3PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3PER { bits } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&self) -> OC3FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3FER { bits } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&mut self) -> _O24CEW { + _O24CEW { w: self } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&mut self) -> _OC4MW { + _OC4MW { w: self } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&mut self) -> _OC4PEW { + _OC4PEW { w: self } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&mut self) -> _OC4FEW { + _OC4FEW { w: self } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&mut self) -> _OC3CEW { + _OC3CEW { w: self } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&mut self) -> _OC3MW { + _OC3MW { w: self } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&mut self) -> _OC3PEW { + _OC3PEW { w: self } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&mut self) -> _OC3FEW { + _OC3FEW { w: self } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim2/ccr1/mod.rs b/src/tim2/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..636721a6705646f2e2f8128b052ff72f4944a757 --- /dev/null +++ b/src/tim2/ccr1/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1_HR { + bits: u16, +} +impl CCR1_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR1_LR { + bits: u16, +} +impl CCR1_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR1_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&self) -> CCR1_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&self) -> CCR1_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&mut self) -> _CCR1_HW { + _CCR1_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&mut self) -> _CCR1_LW { + _CCR1_LW { w: self } + } +} diff --git a/src/tim2/ccr2/mod.rs b/src/tim2/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da5c10c544001e240c4057afa229a389cf835ef6 --- /dev/null +++ b/src/tim2/ccr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2_HR { + bits: u16, +} +impl CCR2_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR2_LR { + bits: u16, +} +impl CCR2_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR2_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&self) -> CCR2_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&self) -> CCR2_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&mut self) -> _CCR2_HW { + _CCR2_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&mut self) -> _CCR2_LW { + _CCR2_LW { w: self } + } +} diff --git a/src/tim2/ccr3/mod.rs b/src/tim2/ccr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ef381cb13f5b57448c0c94ba5fb03455148577b2 --- /dev/null +++ b/src/tim2/ccr3/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR3_HR { + bits: u16, +} +impl CCR3_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR3_LR { + bits: u16, +} +impl CCR3_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR3_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR3_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&self) -> CCR3_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&self) -> CCR3_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&mut self) -> _CCR3_HW { + _CCR3_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&mut self) -> _CCR3_LW { + _CCR3_LW { w: self } + } +} diff --git a/src/tim2/ccr4/mod.rs b/src/tim2/ccr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..35e53a70cc66be4f8d934a48d950910c66075bcd --- /dev/null +++ b/src/tim2/ccr4/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR4_HR { + bits: u16, +} +impl CCR4_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR4_LR { + bits: u16, +} +impl CCR4_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR4_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR4_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&self) -> CCR4_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&self) -> CCR4_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&mut self) -> _CCR4_HW { + _CCR4_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&mut self) -> _CCR4_LW { + _CCR4_LW { w: self } + } +} diff --git a/src/tim2/cnt/mod.rs b/src/tim2/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8e0349113adb724d2b6348681e5de98ff1ed7d1c --- /dev/null +++ b/src/tim2/cnt/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNT_HR { + bits: u16, +} +impl CNT_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CNT_LR { + bits: u16, +} +impl CNT_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNT_HW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNT_LW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&self) -> CNT_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_HR { bits } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&self) -> CNT_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&mut self) -> _CNT_HW { + _CNT_HW { w: self } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&mut self) -> _CNT_LW { + _CNT_LW { w: self } + } +} diff --git a/src/tim2/cr1/mod.rs b/src/tim2/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..164561984a4a4c53f7c4af0afd22d5e56103f974 --- /dev/null +++ b/src/tim2/cr1/mod.rs @@ -0,0 +1,500 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMSR { + bits: u8, +} +impl CMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: bool, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMSW<'a> { + w: &'a mut W, +} +impl<'a> _CMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&self) -> CMSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CMSR { bits } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DIRR { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&mut self) -> _CMSW { + _CMSW { w: self } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim2/cr2/mod.rs b/src/tim2/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..48bd6e6491df1f6bf23d7c41b92f00026c919d97 --- /dev/null +++ b/src/tim2/cr2/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TI1SR { + bits: bool, +} +impl TI1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCDSR { + bits: bool, +} +impl CCDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TI1SW<'a> { + w: &'a mut W, +} +impl<'a> _TI1SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCDSW<'a> { + w: &'a mut W, +} +impl<'a> _CCDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&self) -> TI1SR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TI1SR { bits } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&self) -> CCDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCDSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&mut self) -> _TI1SW { + _TI1SW { w: self } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&mut self) -> _CCDSW { + _CCDSW { w: self } + } +} diff --git a/src/tim2/dcr/mod.rs b/src/tim2/dcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e448383dd86194bcc6682ddee18ee7115780a78 --- /dev/null +++ b/src/tim2/dcr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBLR { + bits: u8, +} +impl DBLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DBAR { + bits: u8, +} +impl DBAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DBLW<'a> { + w: &'a mut W, +} +impl<'a> _DBLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBAW<'a> { + w: &'a mut W, +} +impl<'a> _DBAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&self) -> DBLR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBLR { bits } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&self) -> DBAR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&mut self) -> _DBLW { + _DBLW { w: self } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&mut self) -> _DBAW { + _DBAW { w: self } + } +} diff --git a/src/tim2/dier/mod.rs b/src/tim2/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a70d2f1ace9e20c65260a2f77e3a479fb63d704a --- /dev/null +++ b/src/tim2/dier/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TDER { + bits: bool, +} +impl TDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4DER { + bits: bool, +} +impl CC4DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3DER { + bits: bool, +} +impl CC3DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2DER { + bits: bool, +} +impl CC2DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1DER { + bits: bool, +} +impl CC1DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDER { + bits: bool, +} +impl UDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IER { + bits: bool, +} +impl CC4IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IER { + bits: bool, +} +impl CC3IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TDEW<'a> { + w: &'a mut W, +} +impl<'a> _TDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDEW<'a> { + w: &'a mut W, +} +impl<'a> _UDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&self) -> TDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TDER { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&self) -> CC4DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4DER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&self) -> CC3DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3DER { bits } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&self) -> CC2DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2DER { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&self) -> CC1DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1DER { bits } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&self) -> UDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDER { bits } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&self) -> CC4IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IER { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&self) -> CC3IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&mut self) -> _TDEW { + _TDEW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&mut self) -> _CC4DEW { + _CC4DEW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&mut self) -> _CC3DEW { + _CC3DEW { w: self } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&mut self) -> _CC2DEW { + _CC2DEW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&mut self) -> _CC1DEW { + _CC1DEW { w: self } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&mut self) -> _UDEW { + _UDEW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&mut self) -> _CC4IEW { + _CC4IEW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&mut self) -> _CC3IEW { + _CC3IEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim2/dmar/mod.rs b/src/tim2/dmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61a7e568c1218c1d06c02138357526446d894e0a --- /dev/null +++ b/src/tim2/dmar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMABR { + bits: u16, +} +impl DMABR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DMABW<'a> { + w: &'a mut W, +} +impl<'a> _DMABW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&self) -> DMABR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DMABR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&mut self) -> _DMABW { + _DMABW { w: self } + } +} diff --git a/src/tim2/egr/mod.rs b/src/tim2/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7a199b09ce01340e92960893d5b64601044584c --- /dev/null +++ b/src/tim2/egr/mod.rs @@ -0,0 +1,197 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4GW<'a> { + w: &'a mut W, +} +impl<'a> _CC4GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3GW<'a> { + w: &'a mut W, +} +impl<'a> _CC3GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 4 - Capture/compare 4 generation"] + #[inline] + pub fn cc4g(&mut self) -> _CC4GW { + _CC4GW { w: self } + } + #[doc = "Bit 3 - Capture/compare 3 generation"] + #[inline] + pub fn cc3g(&mut self) -> _CC3GW { + _CC3GW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim2/mod.rs b/src/tim2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f0f0e17dc53061b67ac8f7d9d38fbfa8dcde2ee4 --- /dev/null +++ b/src/tim2/mod.rs @@ -0,0 +1,170 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + #[doc = "0x1c - capture/compare mode register 2 (output mode)"] + pub ccmr2_output: CCMR2_OUTPUT, + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved0: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, + #[doc = "0x3c - capture/compare register 3"] + pub ccr3: CCR3, + #[doc = "0x40 - capture/compare register 4"] + pub ccr4: CCR4, + _reserved1: [u8; 4usize], + #[doc = "0x48 - DMA control register"] + pub dcr: DCR, + #[doc = "0x4c - DMA address for full transfer"] + pub dmar: DMAR, + #[doc = "0x50 - TIM5 option register"] + pub or: OR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare mode register 2 (output mode)"] +pub struct CCMR2_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (output mode)"] +pub mod ccmr2_output; +#[doc = "capture/compare mode register 2 (input mode)"] +pub struct CCMR2_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (input mode)"] +pub mod ccmr2_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; +#[doc = "capture/compare register 3"] +pub struct CCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 3"] +pub mod ccr3; +#[doc = "capture/compare register 4"] +pub struct CCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 4"] +pub mod ccr4; +#[doc = "DMA control register"] +pub struct DCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA control register"] +pub mod dcr; +#[doc = "DMA address for full transfer"] +pub struct DMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA address for full transfer"] +pub mod dmar; +#[doc = "TIM5 option register"] +pub struct OR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "TIM5 option register"] +pub mod or; diff --git a/src/tim2/or/mod.rs b/src/tim2/or/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a46313c75adcddbcdaa75fc94dc93fa96bac5b06 --- /dev/null +++ b/src/tim2/or/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ITR1_RMPR { + bits: u8, +} +impl ITR1_RMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ITR1_RMPW<'a> { + w: &'a mut W, +} +impl<'a> _ITR1_RMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 10:11 - Timer Input 4 remap"] + #[inline] + pub fn itr1_rmp(&self) -> ITR1_RMPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ITR1_RMPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 10:11 - Timer Input 4 remap"] + #[inline] + pub fn itr1_rmp(&mut self) -> _ITR1_RMPW { + _ITR1_RMPW { w: self } + } +} diff --git a/src/tim2/psc/mod.rs b/src/tim2/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim2/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim2/smcr/mod.rs b/src/tim2/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3a864425c88ed3260d3d674aa86079e54f90bf10 --- /dev/null +++ b/src/tim2/smcr/mod.rs @@ -0,0 +1,405 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ETPR { + bits: bool, +} +impl ETPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ECER { + bits: bool, +} +impl ECER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ETPSR { + bits: u8, +} +impl ETPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ETFR { + bits: u8, +} +impl ETFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ETPW<'a> { + w: &'a mut W, +} +impl<'a> _ETPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECEW<'a> { + w: &'a mut W, +} +impl<'a> _ECEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETPSW<'a> { + w: &'a mut W, +} +impl<'a> _ETPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETFW<'a> { + w: &'a mut W, +} +impl<'a> _ETFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&self) -> ETPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ETPR { bits } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&self) -> ECER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECER { bits } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&self) -> ETPSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETPSR { bits } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&self) -> ETFR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETFR { bits } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&mut self) -> _ETPW { + _ETPW { w: self } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&mut self) -> _ECEW { + _ECEW { w: self } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&mut self) -> _ETPSW { + _ETPSW { w: self } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&mut self) -> _ETFW { + _ETFW { w: self } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim2/sr/mod.rs b/src/tim2/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..67abd25a8f974cdf15e08eccd990150dfa11b515 --- /dev/null +++ b/src/tim2/sr/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4OFR { + bits: bool, +} +impl CC4OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3OFR { + bits: bool, +} +impl CC3OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IFR { + bits: bool, +} +impl CC4IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IFR { + bits: bool, +} +impl CC3IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&self) -> CC4OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4OFR { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&self) -> CC3OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3OFR { bits } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&self) -> CC4IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IFR { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&self) -> CC3IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&mut self) -> _CC4OFW { + _CC4OFW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&mut self) -> _CC3OFW { + _CC3OFW { w: self } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&mut self) -> _CC4IFW { + _CC4IFW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&mut self) -> _CC3IFW { + _CC3IFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim3/arr/mod.rs b/src/tim3/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8118e1f3d94628be2f28b732992a94b0e334442c --- /dev/null +++ b/src/tim3/arr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARR_HR { + bits: u16, +} +impl ARR_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARR_LR { + bits: u16, +} +impl ARR_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARR_HW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARR_LW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&self) -> ARR_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_HR { bits } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&self) -> ARR_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&mut self) -> _ARR_HW { + _ARR_HW { w: self } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&mut self) -> _ARR_LW { + _ARR_LW { w: self } + } +} diff --git a/src/tim3/ccer/mod.rs b/src/tim3/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..22f09dea19adf671403a5cb24823a981d4b68d31 --- /dev/null +++ b/src/tim3/ccer/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4NPR { + bits: bool, +} +impl CC4NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4PR { + bits: bool, +} +impl CC4PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4ER { + bits: bool, +} +impl CC4ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3NPR { + bits: bool, +} +impl CC3NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3PR { + bits: bool, +} +impl CC3PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3ER { + bits: bool, +} +impl CC3ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC4NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4PW<'a> { + w: &'a mut W, +} +impl<'a> _CC4PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4EW<'a> { + w: &'a mut W, +} +impl<'a> _CC4EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC3NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3PW<'a> { + w: &'a mut W, +} +impl<'a> _CC3PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3EW<'a> { + w: &'a mut W, +} +impl<'a> _CC3EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&self) -> CC4NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4NPR { bits } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&self) -> CC4PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4PR { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&self) -> CC4ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4ER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&self) -> CC3NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3NPR { bits } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&self) -> CC3PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3PR { bits } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&self) -> CC3ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3ER { bits } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&mut self) -> _CC4NPW { + _CC4NPW { w: self } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&mut self) -> _CC4PW { + _CC4PW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&mut self) -> _CC4EW { + _CC4EW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&mut self) -> _CC3NPW { + _CC3NPW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&mut self) -> _CC3PW { + _CC3PW { w: self } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&mut self) -> _CC3EW { + _CC3EW { w: self } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim3/ccmr1_input/mod.rs b/src/tim3/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eb9746ad82aed1e898e939c332b4cb8d7cf2b665 --- /dev/null +++ b/src/tim3/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PCSR { + bits: u8, +} +impl IC2PCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PCSW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&self) -> IC2PCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PCSR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&mut self) -> _IC2PCSW { + _IC2PCSW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim3/ccmr1_output/mod.rs b/src/tim3/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f71a477d65a5f5915da6ae3dc24c069a7f92105a --- /dev/null +++ b/src/tim3/ccmr1_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2CER { + bits: bool, +} +impl OC2CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1CER { + bits: bool, +} +impl OC1CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&self) -> OC2CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2CER { bits } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&self) -> OC1CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1CER { bits } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&mut self) -> _OC2CEW { + _OC2CEW { w: self } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&mut self) -> _OC1CEW { + _OC1CEW { w: self } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim3/ccmr2_input/mod.rs b/src/tim3/ccmr2_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d3fbf95d0c5bba2ec6b45a3b769c93e39e7b3e3 --- /dev/null +++ b/src/tim3/ccmr2_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC4FR { + bits: u8, +} +impl IC4FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC4PSCR { + bits: u8, +} +impl IC4PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3FR { + bits: u8, +} +impl IC3FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3PSCR { + bits: u8, +} +impl IC3PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC4FW<'a> { + w: &'a mut W, +} +impl<'a> _IC4FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC4PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC4PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3FW<'a> { + w: &'a mut W, +} +impl<'a> _IC3FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC3PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&self) -> IC4FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4FR { bits } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&self) -> IC4PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4PSCR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&self) -> IC3FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3FR { bits } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&self) -> IC3PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&mut self) -> _IC4FW { + _IC4FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&mut self) -> _IC4PSCW { + _IC4PSCW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&mut self) -> _IC3FW { + _IC3FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&mut self) -> _IC3PSCW { + _IC3PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim3/ccmr2_output/mod.rs b/src/tim3/ccmr2_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ea5b84fb77c0bad57434df8d777a8986c7144b17 --- /dev/null +++ b/src/tim3/ccmr2_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct O24CER { + bits: bool, +} +impl O24CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4MR { + bits: u8, +} +impl OC4MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC4PER { + bits: bool, +} +impl OC4PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4FER { + bits: bool, +} +impl OC4FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3CER { + bits: bool, +} +impl OC3CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3MR { + bits: u8, +} +impl OC3MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3PER { + bits: bool, +} +impl OC3PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3FER { + bits: bool, +} +impl OC3FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _O24CEW<'a> { + w: &'a mut W, +} +impl<'a> _O24CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4MW<'a> { + w: &'a mut W, +} +impl<'a> _OC4MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3MW<'a> { + w: &'a mut W, +} +impl<'a> _OC3MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&self) -> O24CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + O24CER { bits } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&self) -> OC4MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC4MR { bits } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&self) -> OC4PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4PER { bits } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&self) -> OC4FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4FER { bits } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&self) -> OC3CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3CER { bits } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&self) -> OC3MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC3MR { bits } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&self) -> OC3PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3PER { bits } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&self) -> OC3FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3FER { bits } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&mut self) -> _O24CEW { + _O24CEW { w: self } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&mut self) -> _OC4MW { + _OC4MW { w: self } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&mut self) -> _OC4PEW { + _OC4PEW { w: self } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&mut self) -> _OC4FEW { + _OC4FEW { w: self } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&mut self) -> _OC3CEW { + _OC3CEW { w: self } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&mut self) -> _OC3MW { + _OC3MW { w: self } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&mut self) -> _OC3PEW { + _OC3PEW { w: self } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&mut self) -> _OC3FEW { + _OC3FEW { w: self } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim3/ccr1/mod.rs b/src/tim3/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..636721a6705646f2e2f8128b052ff72f4944a757 --- /dev/null +++ b/src/tim3/ccr1/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1_HR { + bits: u16, +} +impl CCR1_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR1_LR { + bits: u16, +} +impl CCR1_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR1_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&self) -> CCR1_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&self) -> CCR1_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&mut self) -> _CCR1_HW { + _CCR1_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&mut self) -> _CCR1_LW { + _CCR1_LW { w: self } + } +} diff --git a/src/tim3/ccr2/mod.rs b/src/tim3/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da5c10c544001e240c4057afa229a389cf835ef6 --- /dev/null +++ b/src/tim3/ccr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2_HR { + bits: u16, +} +impl CCR2_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR2_LR { + bits: u16, +} +impl CCR2_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR2_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&self) -> CCR2_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&self) -> CCR2_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&mut self) -> _CCR2_HW { + _CCR2_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&mut self) -> _CCR2_LW { + _CCR2_LW { w: self } + } +} diff --git a/src/tim3/ccr3/mod.rs b/src/tim3/ccr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ef381cb13f5b57448c0c94ba5fb03455148577b2 --- /dev/null +++ b/src/tim3/ccr3/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR3_HR { + bits: u16, +} +impl CCR3_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR3_LR { + bits: u16, +} +impl CCR3_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR3_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR3_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&self) -> CCR3_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&self) -> CCR3_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&mut self) -> _CCR3_HW { + _CCR3_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&mut self) -> _CCR3_LW { + _CCR3_LW { w: self } + } +} diff --git a/src/tim3/ccr4/mod.rs b/src/tim3/ccr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..35e53a70cc66be4f8d934a48d950910c66075bcd --- /dev/null +++ b/src/tim3/ccr4/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR4_HR { + bits: u16, +} +impl CCR4_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR4_LR { + bits: u16, +} +impl CCR4_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR4_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR4_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&self) -> CCR4_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&self) -> CCR4_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&mut self) -> _CCR4_HW { + _CCR4_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&mut self) -> _CCR4_LW { + _CCR4_LW { w: self } + } +} diff --git a/src/tim3/cnt/mod.rs b/src/tim3/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8e0349113adb724d2b6348681e5de98ff1ed7d1c --- /dev/null +++ b/src/tim3/cnt/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNT_HR { + bits: u16, +} +impl CNT_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CNT_LR { + bits: u16, +} +impl CNT_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNT_HW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNT_LW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&self) -> CNT_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_HR { bits } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&self) -> CNT_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&mut self) -> _CNT_HW { + _CNT_HW { w: self } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&mut self) -> _CNT_LW { + _CNT_LW { w: self } + } +} diff --git a/src/tim3/cr1/mod.rs b/src/tim3/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..164561984a4a4c53f7c4af0afd22d5e56103f974 --- /dev/null +++ b/src/tim3/cr1/mod.rs @@ -0,0 +1,500 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMSR { + bits: u8, +} +impl CMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: bool, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMSW<'a> { + w: &'a mut W, +} +impl<'a> _CMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&self) -> CMSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CMSR { bits } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DIRR { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&mut self) -> _CMSW { + _CMSW { w: self } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim3/cr2/mod.rs b/src/tim3/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..48bd6e6491df1f6bf23d7c41b92f00026c919d97 --- /dev/null +++ b/src/tim3/cr2/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TI1SR { + bits: bool, +} +impl TI1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCDSR { + bits: bool, +} +impl CCDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TI1SW<'a> { + w: &'a mut W, +} +impl<'a> _TI1SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCDSW<'a> { + w: &'a mut W, +} +impl<'a> _CCDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&self) -> TI1SR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TI1SR { bits } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&self) -> CCDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCDSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&mut self) -> _TI1SW { + _TI1SW { w: self } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&mut self) -> _CCDSW { + _CCDSW { w: self } + } +} diff --git a/src/tim3/dcr/mod.rs b/src/tim3/dcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e448383dd86194bcc6682ddee18ee7115780a78 --- /dev/null +++ b/src/tim3/dcr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBLR { + bits: u8, +} +impl DBLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DBAR { + bits: u8, +} +impl DBAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DBLW<'a> { + w: &'a mut W, +} +impl<'a> _DBLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBAW<'a> { + w: &'a mut W, +} +impl<'a> _DBAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&self) -> DBLR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBLR { bits } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&self) -> DBAR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&mut self) -> _DBLW { + _DBLW { w: self } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&mut self) -> _DBAW { + _DBAW { w: self } + } +} diff --git a/src/tim3/dier/mod.rs b/src/tim3/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a70d2f1ace9e20c65260a2f77e3a479fb63d704a --- /dev/null +++ b/src/tim3/dier/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TDER { + bits: bool, +} +impl TDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4DER { + bits: bool, +} +impl CC4DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3DER { + bits: bool, +} +impl CC3DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2DER { + bits: bool, +} +impl CC2DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1DER { + bits: bool, +} +impl CC1DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDER { + bits: bool, +} +impl UDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IER { + bits: bool, +} +impl CC4IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IER { + bits: bool, +} +impl CC3IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TDEW<'a> { + w: &'a mut W, +} +impl<'a> _TDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDEW<'a> { + w: &'a mut W, +} +impl<'a> _UDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&self) -> TDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TDER { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&self) -> CC4DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4DER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&self) -> CC3DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3DER { bits } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&self) -> CC2DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2DER { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&self) -> CC1DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1DER { bits } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&self) -> UDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDER { bits } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&self) -> CC4IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IER { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&self) -> CC3IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&mut self) -> _TDEW { + _TDEW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&mut self) -> _CC4DEW { + _CC4DEW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&mut self) -> _CC3DEW { + _CC3DEW { w: self } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&mut self) -> _CC2DEW { + _CC2DEW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&mut self) -> _CC1DEW { + _CC1DEW { w: self } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&mut self) -> _UDEW { + _UDEW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&mut self) -> _CC4IEW { + _CC4IEW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&mut self) -> _CC3IEW { + _CC3IEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim3/dmar/mod.rs b/src/tim3/dmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61a7e568c1218c1d06c02138357526446d894e0a --- /dev/null +++ b/src/tim3/dmar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMABR { + bits: u16, +} +impl DMABR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DMABW<'a> { + w: &'a mut W, +} +impl<'a> _DMABW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&self) -> DMABR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DMABR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&mut self) -> _DMABW { + _DMABW { w: self } + } +} diff --git a/src/tim3/egr/mod.rs b/src/tim3/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7a199b09ce01340e92960893d5b64601044584c --- /dev/null +++ b/src/tim3/egr/mod.rs @@ -0,0 +1,197 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4GW<'a> { + w: &'a mut W, +} +impl<'a> _CC4GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3GW<'a> { + w: &'a mut W, +} +impl<'a> _CC3GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 4 - Capture/compare 4 generation"] + #[inline] + pub fn cc4g(&mut self) -> _CC4GW { + _CC4GW { w: self } + } + #[doc = "Bit 3 - Capture/compare 3 generation"] + #[inline] + pub fn cc3g(&mut self) -> _CC3GW { + _CC3GW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim3/mod.rs b/src/tim3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..d06ccf57a0dccb63d2a910befd8f682411b11abb --- /dev/null +++ b/src/tim3/mod.rs @@ -0,0 +1,162 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + #[doc = "0x1c - capture/compare mode register 2 (output mode)"] + pub ccmr2_output: CCMR2_OUTPUT, + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved0: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, + #[doc = "0x3c - capture/compare register 3"] + pub ccr3: CCR3, + #[doc = "0x40 - capture/compare register 4"] + pub ccr4: CCR4, + _reserved1: [u8; 4usize], + #[doc = "0x48 - DMA control register"] + pub dcr: DCR, + #[doc = "0x4c - DMA address for full transfer"] + pub dmar: DMAR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare mode register 2 (output mode)"] +pub struct CCMR2_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (output mode)"] +pub mod ccmr2_output; +#[doc = "capture/compare mode register 2 (input mode)"] +pub struct CCMR2_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (input mode)"] +pub mod ccmr2_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; +#[doc = "capture/compare register 3"] +pub struct CCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 3"] +pub mod ccr3; +#[doc = "capture/compare register 4"] +pub struct CCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 4"] +pub mod ccr4; +#[doc = "DMA control register"] +pub struct DCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA control register"] +pub mod dcr; +#[doc = "DMA address for full transfer"] +pub struct DMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA address for full transfer"] +pub mod dmar; diff --git a/src/tim3/psc/mod.rs b/src/tim3/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim3/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim3/smcr/mod.rs b/src/tim3/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3a864425c88ed3260d3d674aa86079e54f90bf10 --- /dev/null +++ b/src/tim3/smcr/mod.rs @@ -0,0 +1,405 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ETPR { + bits: bool, +} +impl ETPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ECER { + bits: bool, +} +impl ECER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ETPSR { + bits: u8, +} +impl ETPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ETFR { + bits: u8, +} +impl ETFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ETPW<'a> { + w: &'a mut W, +} +impl<'a> _ETPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECEW<'a> { + w: &'a mut W, +} +impl<'a> _ECEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETPSW<'a> { + w: &'a mut W, +} +impl<'a> _ETPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETFW<'a> { + w: &'a mut W, +} +impl<'a> _ETFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&self) -> ETPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ETPR { bits } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&self) -> ECER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECER { bits } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&self) -> ETPSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETPSR { bits } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&self) -> ETFR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETFR { bits } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&mut self) -> _ETPW { + _ETPW { w: self } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&mut self) -> _ECEW { + _ECEW { w: self } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&mut self) -> _ETPSW { + _ETPSW { w: self } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&mut self) -> _ETFW { + _ETFW { w: self } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim3/sr/mod.rs b/src/tim3/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..67abd25a8f974cdf15e08eccd990150dfa11b515 --- /dev/null +++ b/src/tim3/sr/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4OFR { + bits: bool, +} +impl CC4OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3OFR { + bits: bool, +} +impl CC3OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IFR { + bits: bool, +} +impl CC4IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IFR { + bits: bool, +} +impl CC3IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&self) -> CC4OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4OFR { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&self) -> CC3OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3OFR { bits } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&self) -> CC4IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IFR { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&self) -> CC3IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&mut self) -> _CC4OFW { + _CC4OFW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&mut self) -> _CC3OFW { + _CC3OFW { w: self } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&mut self) -> _CC4IFW { + _CC4IFW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&mut self) -> _CC3IFW { + _CC3IFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim5/arr/mod.rs b/src/tim5/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8118e1f3d94628be2f28b732992a94b0e334442c --- /dev/null +++ b/src/tim5/arr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARR_HR { + bits: u16, +} +impl ARR_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARR_LR { + bits: u16, +} +impl ARR_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARR_HW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARR_LW<'a> { + w: &'a mut W, +} +impl<'a> _ARR_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&self) -> ARR_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_HR { bits } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&self) -> ARR_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARR_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Auto-reload value"] + #[inline] + pub fn arr_h(&mut self) -> _ARR_HW { + _ARR_HW { w: self } + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr_l(&mut self) -> _ARR_LW { + _ARR_LW { w: self } + } +} diff --git a/src/tim5/ccer/mod.rs b/src/tim5/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..22f09dea19adf671403a5cb24823a981d4b68d31 --- /dev/null +++ b/src/tim5/ccer/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4NPR { + bits: bool, +} +impl CC4NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4PR { + bits: bool, +} +impl CC4PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4ER { + bits: bool, +} +impl CC4ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3NPR { + bits: bool, +} +impl CC3NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3PR { + bits: bool, +} +impl CC3PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3ER { + bits: bool, +} +impl CC3ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC4NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4PW<'a> { + w: &'a mut W, +} +impl<'a> _CC4PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4EW<'a> { + w: &'a mut W, +} +impl<'a> _CC4EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC3NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3PW<'a> { + w: &'a mut W, +} +impl<'a> _CC3PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3EW<'a> { + w: &'a mut W, +} +impl<'a> _CC3EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&self) -> CC4NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4NPR { bits } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&self) -> CC4PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4PR { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&self) -> CC4ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4ER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&self) -> CC3NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3NPR { bits } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&self) -> CC3PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3PR { bits } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&self) -> CC3ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3ER { bits } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] + #[inline] + pub fn cc4np(&mut self) -> _CC4NPW { + _CC4NPW { w: self } + } + #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc4p(&mut self) -> _CC4PW { + _CC4PW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 output enable"] + #[inline] + pub fn cc4e(&mut self) -> _CC4EW { + _CC4EW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3np(&mut self) -> _CC3NPW { + _CC3NPW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] + #[inline] + pub fn cc3p(&mut self) -> _CC3PW { + _CC3PW { w: self } + } + #[doc = "Bit 8 - Capture/Compare 3 output enable"] + #[inline] + pub fn cc3e(&mut self) -> _CC3EW { + _CC3EW { w: self } + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim5/ccmr1_input/mod.rs b/src/tim5/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..eb9746ad82aed1e898e939c332b4cb8d7cf2b665 --- /dev/null +++ b/src/tim5/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PCSR { + bits: u8, +} +impl IC2PCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PCSW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&self) -> IC2PCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PCSR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&mut self) -> _IC2PCSW { + _IC2PCSW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim5/ccmr1_output/mod.rs b/src/tim5/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f71a477d65a5f5915da6ae3dc24c069a7f92105a --- /dev/null +++ b/src/tim5/ccmr1_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2CER { + bits: bool, +} +impl OC2CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1CER { + bits: bool, +} +impl OC1CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&self) -> OC2CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2CER { bits } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&self) -> OC1CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1CER { bits } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - OC2CE"] + #[inline] + pub fn oc2ce(&mut self) -> _OC2CEW { + _OC2CEW { w: self } + } + #[doc = "Bits 12:14 - OC2M"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - OC2PE"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - OC2FE"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - CC2S"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bit 7 - OC1CE"] + #[inline] + pub fn oc1ce(&mut self) -> _OC1CEW { + _OC1CEW { w: self } + } + #[doc = "Bits 4:6 - OC1M"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - OC1PE"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - OC1FE"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - CC1S"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim5/ccmr2_input/mod.rs b/src/tim5/ccmr2_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2d3fbf95d0c5bba2ec6b45a3b769c93e39e7b3e3 --- /dev/null +++ b/src/tim5/ccmr2_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC4FR { + bits: u8, +} +impl IC4FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC4PSCR { + bits: u8, +} +impl IC4PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3FR { + bits: u8, +} +impl IC3FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC3PSCR { + bits: u8, +} +impl IC3PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC4FW<'a> { + w: &'a mut W, +} +impl<'a> _IC4FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC4PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC4PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3FW<'a> { + w: &'a mut W, +} +impl<'a> _IC3FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC3PSCW<'a> { + w: &'a mut W, +} +impl<'a> _IC3PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&self) -> IC4FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4FR { bits } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&self) -> IC4PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC4PSCR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&self) -> IC3FR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3FR { bits } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&self) -> IC3PSCR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC3PSCR { bits } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:15 - Input capture 4 filter"] + #[inline] + pub fn ic4f(&mut self) -> _IC4FW { + _IC4FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 4 prescaler"] + #[inline] + pub fn ic4psc(&mut self) -> _IC4PSCW { + _IC4PSCW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 4 selection"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bits 4:7 - Input capture 3 filter"] + #[inline] + pub fn ic3f(&mut self) -> _IC3FW { + _IC3FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 3 prescaler"] + #[inline] + pub fn ic3psc(&mut self) -> _IC3PSCW { + _IC3PSCW { w: self } + } + #[doc = "Bits 0:1 - Capture/compare 3 selection"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim5/ccmr2_output/mod.rs b/src/tim5/ccmr2_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ea5b84fb77c0bad57434df8d777a8986c7144b17 --- /dev/null +++ b/src/tim5/ccmr2_output/mod.rs @@ -0,0 +1,582 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR2_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct O24CER { + bits: bool, +} +impl O24CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4MR { + bits: u8, +} +impl OC4MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC4PER { + bits: bool, +} +impl OC4PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC4FER { + bits: bool, +} +impl OC4FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4SR { + bits: u8, +} +impl CC4SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3CER { + bits: bool, +} +impl OC3CER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3MR { + bits: u8, +} +impl OC3MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC3PER { + bits: bool, +} +impl OC3PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC3FER { + bits: bool, +} +impl OC3FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3SR { + bits: u8, +} +impl CC3SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _O24CEW<'a> { + w: &'a mut W, +} +impl<'a> _O24CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4MW<'a> { + w: &'a mut W, +} +impl<'a> _OC4MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC4FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC4FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4SW<'a> { + w: &'a mut W, +} +impl<'a> _CC4SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3CEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3CEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3MW<'a> { + w: &'a mut W, +} +impl<'a> _OC3MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC3FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC3FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3SW<'a> { + w: &'a mut W, +} +impl<'a> _CC3SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&self) -> O24CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + O24CER { bits } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&self) -> OC4MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC4MR { bits } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&self) -> OC4PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4PER { bits } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&self) -> OC4FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC4FER { bits } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&self) -> CC4SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC4SR { bits } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&self) -> OC3CER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3CER { bits } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&self) -> OC3MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC3MR { bits } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&self) -> OC3PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3PER { bits } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&self) -> OC3FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC3FER { bits } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&self) -> CC3SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC3SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - O24CE"] + #[inline] + pub fn o24ce(&mut self) -> _O24CEW { + _O24CEW { w: self } + } + #[doc = "Bits 12:14 - OC4M"] + #[inline] + pub fn oc4m(&mut self) -> _OC4MW { + _OC4MW { w: self } + } + #[doc = "Bit 11 - OC4PE"] + #[inline] + pub fn oc4pe(&mut self) -> _OC4PEW { + _OC4PEW { w: self } + } + #[doc = "Bit 10 - OC4FE"] + #[inline] + pub fn oc4fe(&mut self) -> _OC4FEW { + _OC4FEW { w: self } + } + #[doc = "Bits 8:9 - CC4S"] + #[inline] + pub fn cc4s(&mut self) -> _CC4SW { + _CC4SW { w: self } + } + #[doc = "Bit 7 - OC3CE"] + #[inline] + pub fn oc3ce(&mut self) -> _OC3CEW { + _OC3CEW { w: self } + } + #[doc = "Bits 4:6 - OC3M"] + #[inline] + pub fn oc3m(&mut self) -> _OC3MW { + _OC3MW { w: self } + } + #[doc = "Bit 3 - OC3PE"] + #[inline] + pub fn oc3pe(&mut self) -> _OC3PEW { + _OC3PEW { w: self } + } + #[doc = "Bit 2 - OC3FE"] + #[inline] + pub fn oc3fe(&mut self) -> _OC3FEW { + _OC3FEW { w: self } + } + #[doc = "Bits 0:1 - CC3S"] + #[inline] + pub fn cc3s(&mut self) -> _CC3SW { + _CC3SW { w: self } + } +} diff --git a/src/tim5/ccr1/mod.rs b/src/tim5/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..636721a6705646f2e2f8128b052ff72f4944a757 --- /dev/null +++ b/src/tim5/ccr1/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1_HR { + bits: u16, +} +impl CCR1_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR1_LR { + bits: u16, +} +impl CCR1_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR1_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR1_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&self) -> CCR1_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&self) -> CCR1_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 1 value"] + #[inline] + pub fn ccr1_h(&mut self) -> _CCR1_HW { + _CCR1_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] + #[inline] + pub fn ccr1_l(&mut self) -> _CCR1_LW { + _CCR1_LW { w: self } + } +} diff --git a/src/tim5/ccr2/mod.rs b/src/tim5/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..da5c10c544001e240c4057afa229a389cf835ef6 --- /dev/null +++ b/src/tim5/ccr2/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2_HR { + bits: u16, +} +impl CCR2_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR2_LR { + bits: u16, +} +impl CCR2_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR2_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR2_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&self) -> CCR2_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&self) -> CCR2_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare 2 value"] + #[inline] + pub fn ccr2_h(&mut self) -> _CCR2_HW { + _CCR2_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] + #[inline] + pub fn ccr2_l(&mut self) -> _CCR2_LW { + _CCR2_LW { w: self } + } +} diff --git a/src/tim5/ccr3/mod.rs b/src/tim5/ccr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ef381cb13f5b57448c0c94ba5fb03455148577b2 --- /dev/null +++ b/src/tim5/ccr3/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR3_HR { + bits: u16, +} +impl CCR3_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR3_LR { + bits: u16, +} +impl CCR3_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR3_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR3_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR3_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&self) -> CCR3_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&self) -> CCR3_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR3_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr3_h(&mut self) -> _CCR3_HW { + _CCR3_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr3_l(&mut self) -> _CCR3_LW { + _CCR3_LW { w: self } + } +} diff --git a/src/tim5/ccr4/mod.rs b/src/tim5/ccr4/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..35e53a70cc66be4f8d934a48d950910c66075bcd --- /dev/null +++ b/src/tim5/ccr4/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR4 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR4_HR { + bits: u16, +} +impl CCR4_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCR4_LR { + bits: u16, +} +impl CCR4_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR4_HW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCR4_LW<'a> { + w: &'a mut W, +} +impl<'a> _CCR4_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&self) -> CCR4_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_HR { bits } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&self) -> CCR4_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR4_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High Capture/Compare value"] + #[inline] + pub fn ccr4_h(&mut self) -> _CCR4_HW { + _CCR4_HW { w: self } + } + #[doc = "Bits 0:15 - Low Capture/Compare value"] + #[inline] + pub fn ccr4_l(&mut self) -> _CCR4_LW { + _CCR4_LW { w: self } + } +} diff --git a/src/tim5/cnt/mod.rs b/src/tim5/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..8e0349113adb724d2b6348681e5de98ff1ed7d1c --- /dev/null +++ b/src/tim5/cnt/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNT_HR { + bits: u16, +} +impl CNT_HR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CNT_LR { + bits: u16, +} +impl CNT_LR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNT_HW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_HW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CNT_LW<'a> { + w: &'a mut W, +} +impl<'a> _CNT_LW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&self) -> CNT_HR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 16; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_HR { bits } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&self) -> CNT_LR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNT_LR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 16:31 - High counter value"] + #[inline] + pub fn cnt_h(&mut self) -> _CNT_HW { + _CNT_HW { w: self } + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt_l(&mut self) -> _CNT_LW { + _CNT_LW { w: self } + } +} diff --git a/src/tim5/cr1/mod.rs b/src/tim5/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..164561984a4a4c53f7c4af0afd22d5e56103f974 --- /dev/null +++ b/src/tim5/cr1/mod.rs @@ -0,0 +1,500 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CMSR { + bits: u8, +} +impl CMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DIRR { + bits: bool, +} +impl DIRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CMSW<'a> { + w: &'a mut W, +} +impl<'a> _CMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIRW<'a> { + w: &'a mut W, +} +impl<'a> _DIRW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&self) -> CMSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CMSR { bits } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&self) -> DIRR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DIRR { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bits 5:6 - Center-aligned mode selection"] + #[inline] + pub fn cms(&mut self) -> _CMSW { + _CMSW { w: self } + } + #[doc = "Bit 4 - Direction"] + #[inline] + pub fn dir(&mut self) -> _DIRW { + _DIRW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim5/cr2/mod.rs b/src/tim5/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..48bd6e6491df1f6bf23d7c41b92f00026c919d97 --- /dev/null +++ b/src/tim5/cr2/mod.rs @@ -0,0 +1,223 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TI1SR { + bits: bool, +} +impl TI1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CCDSR { + bits: bool, +} +impl CCDSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TI1SW<'a> { + w: &'a mut W, +} +impl<'a> _TI1SW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CCDSW<'a> { + w: &'a mut W, +} +impl<'a> _CCDSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&self) -> TI1SR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TI1SR { bits } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&self) -> CCDSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CCDSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - TI1 selection"] + #[inline] + pub fn ti1s(&mut self) -> _TI1SW { + _TI1SW { w: self } + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } + #[doc = "Bit 3 - Capture/compare DMA selection"] + #[inline] + pub fn ccds(&mut self) -> _CCDSW { + _CCDSW { w: self } + } +} diff --git a/src/tim5/dcr/mod.rs b/src/tim5/dcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0e448383dd86194bcc6682ddee18ee7115780a78 --- /dev/null +++ b/src/tim5/dcr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DBLR { + bits: u8, +} +impl DBLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DBAR { + bits: u8, +} +impl DBAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DBLW<'a> { + w: &'a mut W, +} +impl<'a> _DBLW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DBAW<'a> { + w: &'a mut W, +} +impl<'a> _DBAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&self) -> DBLR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBLR { bits } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&self) -> DBAR { + let bits = { + const MASK: u8 = 31; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DBAR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:12 - DMA burst length"] + #[inline] + pub fn dbl(&mut self) -> _DBLW { + _DBLW { w: self } + } + #[doc = "Bits 0:4 - DMA base address"] + #[inline] + pub fn dba(&mut self) -> _DBAW { + _DBAW { w: self } + } +} diff --git a/src/tim5/dier/mod.rs b/src/tim5/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a70d2f1ace9e20c65260a2f77e3a479fb63d704a --- /dev/null +++ b/src/tim5/dier/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TDER { + bits: bool, +} +impl TDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4DER { + bits: bool, +} +impl CC4DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3DER { + bits: bool, +} +impl CC3DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2DER { + bits: bool, +} +impl CC2DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1DER { + bits: bool, +} +impl CC1DER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDER { + bits: bool, +} +impl UDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IER { + bits: bool, +} +impl CC4IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IER { + bits: bool, +} +impl CC3IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TDEW<'a> { + w: &'a mut W, +} +impl<'a> _TDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1DEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1DEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDEW<'a> { + w: &'a mut W, +} +impl<'a> _UDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&self) -> TDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TDER { bits } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&self) -> CC4DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4DER { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&self) -> CC3DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3DER { bits } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&self) -> CC2DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2DER { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&self) -> CC1DER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1DER { bits } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&self) -> UDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDER { bits } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&self) -> CC4IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IER { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&self) -> CC3IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - Trigger DMA request enable"] + #[inline] + pub fn tde(&mut self) -> _TDEW { + _TDEW { w: self } + } + #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] + #[inline] + pub fn cc4de(&mut self) -> _CC4DEW { + _CC4DEW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] + #[inline] + pub fn cc3de(&mut self) -> _CC3DEW { + _CC3DEW { w: self } + } + #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] + #[inline] + pub fn cc2de(&mut self) -> _CC2DEW { + _CC2DEW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] + #[inline] + pub fn cc1de(&mut self) -> _CC1DEW { + _CC1DEW { w: self } + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&mut self) -> _UDEW { + _UDEW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] + #[inline] + pub fn cc4ie(&mut self) -> _CC4IEW { + _CC4IEW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] + #[inline] + pub fn cc3ie(&mut self) -> _CC3IEW { + _CC3IEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim5/dmar/mod.rs b/src/tim5/dmar/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..61a7e568c1218c1d06c02138357526446d894e0a --- /dev/null +++ b/src/tim5/dmar/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DMAR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DMABR { + bits: u16, +} +impl DMABR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DMABW<'a> { + w: &'a mut W, +} +impl<'a> _DMABW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&self) -> DMABR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DMABR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - DMA register for burst accesses"] + #[inline] + pub fn dmab(&mut self) -> _DMABW { + _DMABW { w: self } + } +} diff --git a/src/tim5/egr/mod.rs b/src/tim5/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e7a199b09ce01340e92960893d5b64601044584c --- /dev/null +++ b/src/tim5/egr/mod.rs @@ -0,0 +1,197 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4GW<'a> { + w: &'a mut W, +} +impl<'a> _CC4GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3GW<'a> { + w: &'a mut W, +} +impl<'a> _CC3GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 4 - Capture/compare 4 generation"] + #[inline] + pub fn cc4g(&mut self) -> _CC4GW { + _CC4GW { w: self } + } + #[doc = "Bit 3 - Capture/compare 3 generation"] + #[inline] + pub fn cc3g(&mut self) -> _CC3GW { + _CC3GW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim5/mod.rs b/src/tim5/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..f0f0e17dc53061b67ac8f7d9d38fbfa8dcde2ee4 --- /dev/null +++ b/src/tim5/mod.rs @@ -0,0 +1,170 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + #[doc = "0x1c - capture/compare mode register 2 (output mode)"] + pub ccmr2_output: CCMR2_OUTPUT, + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved0: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, + #[doc = "0x3c - capture/compare register 3"] + pub ccr3: CCR3, + #[doc = "0x40 - capture/compare register 4"] + pub ccr4: CCR4, + _reserved1: [u8; 4usize], + #[doc = "0x48 - DMA control register"] + pub dcr: DCR, + #[doc = "0x4c - DMA address for full transfer"] + pub dmar: DMAR, + #[doc = "0x50 - TIM5 option register"] + pub or: OR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare mode register 2 (output mode)"] +pub struct CCMR2_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (output mode)"] +pub mod ccmr2_output; +#[doc = "capture/compare mode register 2 (input mode)"] +pub struct CCMR2_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 2 (input mode)"] +pub mod ccmr2_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; +#[doc = "capture/compare register 3"] +pub struct CCR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 3"] +pub mod ccr3; +#[doc = "capture/compare register 4"] +pub struct CCR4 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 4"] +pub mod ccr4; +#[doc = "DMA control register"] +pub struct DCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA control register"] +pub mod dcr; +#[doc = "DMA address for full transfer"] +pub struct DMAR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA address for full transfer"] +pub mod dmar; +#[doc = "TIM5 option register"] +pub struct OR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "TIM5 option register"] +pub mod or; diff --git a/src/tim5/or/mod.rs b/src/tim5/or/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c57c1518be369b4f1f8f53b80648d0c3e0286f33 --- /dev/null +++ b/src/tim5/or/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::OR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IT4_RMPR { + bits: u8, +} +impl IT4_RMPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IT4_RMPW<'a> { + w: &'a mut W, +} +impl<'a> _IT4_RMPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 6:7 - Timer Input 4 remap"] + #[inline] + pub fn it4_rmp(&self) -> IT4_RMPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IT4_RMPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 6:7 - Timer Input 4 remap"] + #[inline] + pub fn it4_rmp(&mut self) -> _IT4_RMPW { + _IT4_RMPW { w: self } + } +} diff --git a/src/tim5/psc/mod.rs b/src/tim5/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim5/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim5/smcr/mod.rs b/src/tim5/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..3a864425c88ed3260d3d674aa86079e54f90bf10 --- /dev/null +++ b/src/tim5/smcr/mod.rs @@ -0,0 +1,405 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ETPR { + bits: bool, +} +impl ETPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ECER { + bits: bool, +} +impl ECER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ETPSR { + bits: u8, +} +impl ETPSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ETFR { + bits: u8, +} +impl ETFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ETPW<'a> { + w: &'a mut W, +} +impl<'a> _ETPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ECEW<'a> { + w: &'a mut W, +} +impl<'a> _ECEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETPSW<'a> { + w: &'a mut W, +} +impl<'a> _ETPSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ETFW<'a> { + w: &'a mut W, +} +impl<'a> _ETFW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&self) -> ETPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ETPR { bits } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&self) -> ECER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ECER { bits } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&self) -> ETPSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETPSR { bits } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&self) -> ETFR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ETFR { bits } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - External trigger polarity"] + #[inline] + pub fn etp(&mut self) -> _ETPW { + _ETPW { w: self } + } + #[doc = "Bit 14 - External clock enable"] + #[inline] + pub fn ece(&mut self) -> _ECEW { + _ECEW { w: self } + } + #[doc = "Bits 12:13 - External trigger prescaler"] + #[inline] + pub fn etps(&mut self) -> _ETPSW { + _ETPSW { w: self } + } + #[doc = "Bits 8:11 - External trigger filter"] + #[inline] + pub fn etf(&mut self) -> _ETFW { + _ETFW { w: self } + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim5/sr/mod.rs b/src/tim5/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..67abd25a8f974cdf15e08eccd990150dfa11b515 --- /dev/null +++ b/src/tim5/sr/mod.rs @@ -0,0 +1,654 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC4OFR { + bits: bool, +} +impl CC4OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3OFR { + bits: bool, +} +impl CC3OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC4IFR { + bits: bool, +} +impl CC4IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC3IFR { + bits: bool, +} +impl CC3IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC4OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC4IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC4IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC3IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC3IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&self) -> CC4OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4OFR { bits } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&self) -> CC3OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3OFR { bits } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&self) -> CC4IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC4IFR { bits } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&self) -> CC3IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC3IFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] + #[inline] + pub fn cc4of(&mut self) -> _CC4OFW { + _CC4OFW { w: self } + } + #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] + #[inline] + pub fn cc3of(&mut self) -> _CC3OFW { + _CC3OFW { w: self } + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] + #[inline] + pub fn cc4if(&mut self) -> _CC4IFW { + _CC4IFW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] + #[inline] + pub fn cc3if(&mut self) -> _CC3IFW { + _CC3IFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim6/arr/mod.rs b/src/tim6/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aa9abd3f9fa1b6be1f579cd02105ada5d5218bde --- /dev/null +++ b/src/tim6/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Low Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim6/cnt/mod.rs b/src/tim6/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a4090ebd496b380f5f787fabf0b479eaa8522d11 --- /dev/null +++ b/src/tim6/cnt/mod.rs @@ -0,0 +1,136 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct UIFCPYR { + bits: bool, +} +impl UIFCPYR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } + #[doc = "Bit 31 - UIF Copy"] + #[inline] + pub fn uifcpy(&self) -> UIFCPYR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 31; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFCPYR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Low counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim6/cr1/mod.rs b/src/tim6/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1ff75eeb6ae9dd2c6d83c2ec7c1fe36c15082e17 --- /dev/null +++ b/src/tim6/cr1/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFREMAPR { + bits: bool, +} +impl UIFREMAPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFREMAPW<'a> { + w: &'a mut W, +} +impl<'a> _UIFREMAPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 11 - UIF status bit remapping"] + #[inline] + pub fn uifremap(&self) -> UIFREMAPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFREMAPR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 11 - UIF status bit remapping"] + #[inline] + pub fn uifremap(&mut self) -> _UIFREMAPW { + _UIFREMAPW { w: self } + } +} diff --git a/src/tim6/cr2/mod.rs b/src/tim6/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8ebfcdd223f2717eaa3b949d41336e8a3de1aac --- /dev/null +++ b/src/tim6/cr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } +} diff --git a/src/tim6/dier/mod.rs b/src/tim6/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c91107354ad9c400f17b9ebcd68956aedc748e97 --- /dev/null +++ b/src/tim6/dier/mod.rs @@ -0,0 +1,182 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct UDER { + bits: bool, +} +impl UDER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _UDEW<'a> { + w: &'a mut W, +} +impl<'a> _UDEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&self) -> UDER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 8 - Update DMA request enable"] + #[inline] + pub fn ude(&mut self) -> _UDEW { + _UDEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim6/egr/mod.rs b/src/tim6/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ba88ba7b7da8be2da911458728deef236bbcff5e --- /dev/null +++ b/src/tim6/egr/mod.rs @@ -0,0 +1,57 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim6/mod.rs b/src/tim6/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c5f2a4e2f9a60c72d8e881bb009c978be5402b87 --- /dev/null +++ b/src/tim6/mod.rs @@ -0,0 +1,70 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + _reserved0: [u8; 4usize], + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + _reserved1: [u8; 12usize], + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; diff --git a/src/tim6/psc/mod.rs b/src/tim6/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim6/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim6/sr/mod.rs b/src/tim6/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..2829f925175046a87269156b388ade245e84bae4 --- /dev/null +++ b/src/tim6/sr/mod.rs @@ -0,0 +1,123 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/tim9/arr/mod.rs b/src/tim9/arr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6c7b4670f072996f359c525591d4be06c2190e06 --- /dev/null +++ b/src/tim9/arr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::ARR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ARRR { + bits: u16, +} +impl ARRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _ARRW<'a> { + w: &'a mut W, +} +impl<'a> _ARRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&self) -> ARRR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + ARRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Auto-reload value"] + #[inline] + pub fn arr(&mut self) -> _ARRW { + _ARRW { w: self } + } +} diff --git a/src/tim9/ccer/mod.rs b/src/tim9/ccer/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c489e741a0ea907d9c0e6eb7fc8dcb96691f90fa --- /dev/null +++ b/src/tim9/ccer/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC2NPR { + bits: bool, +} +impl CC2NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2PR { + bits: bool, +} +impl CC2PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2ER { + bits: bool, +} +impl CC2ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1NPR { + bits: bool, +} +impl CC1NPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1PR { + bits: bool, +} +impl CC1PR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1ER { + bits: bool, +} +impl CC1ER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC2NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC2NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2PW<'a> { + w: &'a mut W, +} +impl<'a> _CC2PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2EW<'a> { + w: &'a mut W, +} +impl<'a> _CC2EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1NPW<'a> { + w: &'a mut W, +} +impl<'a> _CC1NPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1PW<'a> { + w: &'a mut W, +} +impl<'a> _CC1PW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1EW<'a> { + w: &'a mut W, +} +impl<'a> _CC1EW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&self) -> CC2NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2NPR { bits } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&self) -> CC2PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2PR { bits } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&self) -> CC2ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2ER { bits } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&self) -> CC1NPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1NPR { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&self) -> CC1PR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1PR { bits } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&self) -> CC1ER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1ER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2np(&mut self) -> _CC2NPW { + _CC2NPW { w: self } + } + #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] + #[inline] + pub fn cc2p(&mut self) -> _CC2PW { + _CC2PW { w: self } + } + #[doc = "Bit 4 - Capture/Compare 2 output enable"] + #[inline] + pub fn cc2e(&mut self) -> _CC2EW { + _CC2EW { w: self } + } + #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1np(&mut self) -> _CC1NPW { + _CC1NPW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] + #[inline] + pub fn cc1p(&mut self) -> _CC1PW { + _CC1PW { w: self } + } + #[doc = "Bit 0 - Capture/Compare 1 output enable"] + #[inline] + pub fn cc1e(&mut self) -> _CC1EW { + _CC1EW { w: self } + } +} diff --git a/src/tim9/ccmr1_input/mod.rs b/src/tim9/ccmr1_input/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1b6368066a3cbe18def5f24f790702cbc2072001 --- /dev/null +++ b/src/tim9/ccmr1_input/mod.rs @@ -0,0 +1,310 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_INPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct IC2FR { + bits: u8, +} +impl IC2FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC2PCSR { + bits: u8, +} +impl IC2PCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct IC1FR { + bits: u8, +} +impl IC1FR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ICPCSR { + bits: u8, +} +impl ICPCSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _IC2FW<'a> { + w: &'a mut W, +} +impl<'a> _IC2FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC2PCSW<'a> { + w: &'a mut W, +} +impl<'a> _IC2PCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IC1FW<'a> { + w: &'a mut W, +} +impl<'a> _IC1FW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ICPCSW<'a> { + w: &'a mut W, +} +impl<'a> _ICPCSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:14 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&self) -> IC2FR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2FR { bits } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&self) -> IC2PCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC2PCSR { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:6 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&self) -> IC1FR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + IC1FR { bits } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&self) -> ICPCSR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ICPCSR { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:14 - Input capture 2 filter"] + #[inline] + pub fn ic2f(&mut self) -> _IC2FW { + _IC2FW { w: self } + } + #[doc = "Bits 10:11 - Input capture 2 prescaler"] + #[inline] + pub fn ic2pcs(&mut self) -> _IC2PCSW { + _IC2PCSW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:6 - Input capture 1 filter"] + #[inline] + pub fn ic1f(&mut self) -> _IC1FW { + _IC1FW { w: self } + } + #[doc = "Bits 2:3 - Input capture 1 prescaler"] + #[inline] + pub fn icpcs(&mut self) -> _ICPCSW { + _ICPCSW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim9/ccmr1_output/mod.rs b/src/tim9/ccmr1_output/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..c2eaa5569197cd3e4fc68ba73ad12636b5c7b428 --- /dev/null +++ b/src/tim9/ccmr1_output/mod.rs @@ -0,0 +1,464 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCMR1_OUTPUT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OC2MR { + bits: u8, +} +impl OC2MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC2PER { + bits: bool, +} +impl OC2PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC2FER { + bits: bool, +} +impl OC2FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2SR { + bits: u8, +} +impl CC2SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1MR { + bits: u8, +} +impl OC1MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct OC1PER { + bits: bool, +} +impl OC1PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OC1FER { + bits: bool, +} +impl OC1FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1SR { + bits: u8, +} +impl CC1SR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _OC2MW<'a> { + w: &'a mut W, +} +impl<'a> _OC2MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC2FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC2FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2SW<'a> { + w: &'a mut W, +} +impl<'a> _CC2SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1MW<'a> { + w: &'a mut W, +} +impl<'a> _OC1MW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1PEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1PEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OC1FEW<'a> { + w: &'a mut W, +} +impl<'a> _OC1FEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1SW<'a> { + w: &'a mut W, +} +impl<'a> _CC1SW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&self) -> OC2MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC2MR { bits } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&self) -> OC2PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2PER { bits } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&self) -> OC2FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC2FER { bits } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&self) -> CC2SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC2SR { bits } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&self) -> OC1MR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + OC1MR { bits } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&self) -> OC1PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1PER { bits } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&self) -> OC1FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OC1FER { bits } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&self) -> CC1SR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CC1SR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 12:14 - Output Compare 2 mode"] + #[inline] + pub fn oc2m(&mut self) -> _OC2MW { + _OC2MW { w: self } + } + #[doc = "Bit 11 - Output Compare 2 preload enable"] + #[inline] + pub fn oc2pe(&mut self) -> _OC2PEW { + _OC2PEW { w: self } + } + #[doc = "Bit 10 - Output Compare 2 fast enable"] + #[inline] + pub fn oc2fe(&mut self) -> _OC2FEW { + _OC2FEW { w: self } + } + #[doc = "Bits 8:9 - Capture/Compare 2 selection"] + #[inline] + pub fn cc2s(&mut self) -> _CC2SW { + _CC2SW { w: self } + } + #[doc = "Bits 4:6 - Output Compare 1 mode"] + #[inline] + pub fn oc1m(&mut self) -> _OC1MW { + _OC1MW { w: self } + } + #[doc = "Bit 3 - Output Compare 1 preload enable"] + #[inline] + pub fn oc1pe(&mut self) -> _OC1PEW { + _OC1PEW { w: self } + } + #[doc = "Bit 2 - Output Compare 1 fast enable"] + #[inline] + pub fn oc1fe(&mut self) -> _OC1FEW { + _OC1FEW { w: self } + } + #[doc = "Bits 0:1 - Capture/Compare 1 selection"] + #[inline] + pub fn cc1s(&mut self) -> _CC1SW { + _CC1SW { w: self } + } +} diff --git a/src/tim9/ccr1/mod.rs b/src/tim9/ccr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..50404b3dbab2cc1c6162f614495c077659ae94c1 --- /dev/null +++ b/src/tim9/ccr1/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR1R { + bits: u16, +} +impl CCR1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR1W<'a> { + w: &'a mut W, +} +impl<'a> _CCR1W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&self) -> CCR1R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR1R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 1 value"] + #[inline] + pub fn ccr1(&mut self) -> _CCR1W { + _CCR1W { w: self } + } +} diff --git a/src/tim9/ccr2/mod.rs b/src/tim9/ccr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..869f0bd5a0fa31bc5a322cd76f260653eb9c8ca8 --- /dev/null +++ b/src/tim9/ccr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CCR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CCR2R { + bits: u16, +} +impl CCR2R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CCR2W<'a> { + w: &'a mut W, +} +impl<'a> _CCR2W<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&self) -> CCR2R { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CCR2R { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Capture/Compare 2 value"] + #[inline] + pub fn ccr2(&mut self) -> _CCR2W { + _CCR2W { w: self } + } +} diff --git a/src/tim9/cnt/mod.rs b/src/tim9/cnt/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..9f5a76bb6c6692356ebdf59a4de7e260f34cab90 --- /dev/null +++ b/src/tim9/cnt/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CNT { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CNTR { + bits: u16, +} +impl CNTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _CNTW<'a> { + w: &'a mut W, +} +impl<'a> _CNTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&self) -> CNTR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + CNTR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - counter value"] + #[inline] + pub fn cnt(&mut self) -> _CNTW { + _CNTW { w: self } + } +} diff --git a/src/tim9/cr1/mod.rs b/src/tim9/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..4d7c3931977c84874b79f366865477e9b55050b6 --- /dev/null +++ b/src/tim9/cr1/mod.rs @@ -0,0 +1,400 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CKDR { + bits: u8, +} +impl CKDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct ARPER { + bits: bool, +} +impl ARPER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct OPMR { + bits: bool, +} +impl OPMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct URSR { + bits: bool, +} +impl URSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UDISR { + bits: bool, +} +impl UDISR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CENR { + bits: bool, +} +impl CENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CKDW<'a> { + w: &'a mut W, +} +impl<'a> _CKDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ARPEW<'a> { + w: &'a mut W, +} +impl<'a> _ARPEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _OPMW<'a> { + w: &'a mut W, +} +impl<'a> _OPMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _URSW<'a> { + w: &'a mut W, +} +impl<'a> _URSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UDISW<'a> { + w: &'a mut W, +} +impl<'a> _UDISW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CENW<'a> { + w: &'a mut W, +} +impl<'a> _CENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&self) -> CKDR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + CKDR { bits } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&self) -> ARPER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ARPER { bits } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&self) -> OPMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OPMR { bits } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&self) -> URSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + URSR { bits } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&self) -> UDISR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UDISR { bits } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&self) -> CENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CENR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:9 - Clock division"] + #[inline] + pub fn ckd(&mut self) -> _CKDW { + _CKDW { w: self } + } + #[doc = "Bit 7 - Auto-reload preload enable"] + #[inline] + pub fn arpe(&mut self) -> _ARPEW { + _ARPEW { w: self } + } + #[doc = "Bit 3 - One-pulse mode"] + #[inline] + pub fn opm(&mut self) -> _OPMW { + _OPMW { w: self } + } + #[doc = "Bit 2 - Update request source"] + #[inline] + pub fn urs(&mut self) -> _URSW { + _URSW { w: self } + } + #[doc = "Bit 1 - Update disable"] + #[inline] + pub fn udis(&mut self) -> _UDISW { + _UDISW { w: self } + } + #[doc = "Bit 0 - Counter enable"] + #[inline] + pub fn cen(&mut self) -> _CENW { + _CENW { w: self } + } +} diff --git a/src/tim9/cr2/mod.rs b/src/tim9/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e8ebfcdd223f2717eaa3b949d41336e8a3de1aac --- /dev/null +++ b/src/tim9/cr2/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MMSR { + bits: u8, +} +impl MMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MMSW<'a> { + w: &'a mut W, +} +impl<'a> _MMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&self) -> MMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + MMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:6 - Master mode selection"] + #[inline] + pub fn mms(&mut self) -> _MMSW { + _MMSW { w: self } + } +} diff --git a/src/tim9/dier/mod.rs b/src/tim9/dier/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1362aa66aee8b1b011ca59fbba6fc7a1a957c1b8 --- /dev/null +++ b/src/tim9/dier/mod.rs @@ -0,0 +1,300 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DIER { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct TIER { + bits: bool, +} +impl TIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IER { + bits: bool, +} +impl CC2IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IER { + bits: bool, +} +impl CC1IER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIER { + bits: bool, +} +impl UIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _TIEW<'a> { + w: &'a mut W, +} +impl<'a> _TIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IEW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIEW<'a> { + w: &'a mut W, +} +impl<'a> _UIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&self) -> TIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIER { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&self) -> CC2IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IER { bits } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&self) -> CC1IER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IER { bits } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&self) -> UIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger interrupt enable"] + #[inline] + pub fn tie(&mut self) -> _TIEW { + _TIEW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] + #[inline] + pub fn cc2ie(&mut self) -> _CC2IEW { + _CC2IEW { w: self } + } + #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] + #[inline] + pub fn cc1ie(&mut self) -> _CC1IEW { + _CC1IEW { w: self } + } + #[doc = "Bit 0 - Update interrupt enable"] + #[inline] + pub fn uie(&mut self) -> _UIEW { + _UIEW { w: self } + } +} diff --git a/src/tim9/egr/mod.rs b/src/tim9/egr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b06767684dc060a6053c0af73e0e1223c3872c64 --- /dev/null +++ b/src/tim9/egr/mod.rs @@ -0,0 +1,141 @@ +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::EGR { + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } +} +#[doc = r" Proxy"] +pub struct _TGW<'a> { + w: &'a mut W, +} +impl<'a> _TGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2GW<'a> { + w: &'a mut W, +} +impl<'a> _CC2GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1GW<'a> { + w: &'a mut W, +} +impl<'a> _CC1GW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UGW<'a> { + w: &'a mut W, +} +impl<'a> _UGW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 6 - Trigger generation"] + #[inline] + pub fn tg(&mut self) -> _TGW { + _TGW { w: self } + } + #[doc = "Bit 2 - Capture/compare 2 generation"] + #[inline] + pub fn cc2g(&mut self) -> _CC2GW { + _CC2GW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 generation"] + #[inline] + pub fn cc1g(&mut self) -> _CC1GW { + _CC1GW { w: self } + } + #[doc = "Bit 0 - Update generation"] + #[inline] + pub fn ug(&mut self) -> _UGW { + _UGW { w: self } + } +} diff --git a/src/tim9/mod.rs b/src/tim9/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..59a5037a68371d1568cff09501c7451cf2639bb3 --- /dev/null +++ b/src/tim9/mod.rs @@ -0,0 +1,116 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - control register 1"] + pub cr1: CR1, + #[doc = "0x04 - control register 2"] + pub cr2: CR2, + #[doc = "0x08 - slave mode control register"] + pub smcr: SMCR, + #[doc = "0x0c - DMA/Interrupt enable register"] + pub dier: DIER, + #[doc = "0x10 - status register"] + pub sr: SR, + #[doc = "0x14 - event generation register"] + pub egr: EGR, + #[doc = "0x18 - capture/compare mode register 1 (output mode)"] + pub ccmr1_output: CCMR1_OUTPUT, + _reserved0: [u8; 4usize], + #[doc = "0x20 - capture/compare enable register"] + pub ccer: CCER, + #[doc = "0x24 - counter"] + pub cnt: CNT, + #[doc = "0x28 - prescaler"] + pub psc: PSC, + #[doc = "0x2c - auto-reload register"] + pub arr: ARR, + _reserved1: [u8; 4usize], + #[doc = "0x34 - capture/compare register 1"] + pub ccr1: CCR1, + #[doc = "0x38 - capture/compare register 2"] + pub ccr2: CCR2, +} +#[doc = "control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 1"] +pub mod cr1; +#[doc = "control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "control register 2"] +pub mod cr2; +#[doc = "slave mode control register"] +pub struct SMCR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "slave mode control register"] +pub mod smcr; +#[doc = "DMA/Interrupt enable register"] +pub struct DIER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "DMA/Interrupt enable register"] +pub mod dier; +#[doc = "status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "status register"] +pub mod sr; +#[doc = "event generation register"] +pub struct EGR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "event generation register"] +pub mod egr; +#[doc = "capture/compare mode register 1 (output mode)"] +pub struct CCMR1_OUTPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (output mode)"] +pub mod ccmr1_output; +#[doc = "capture/compare mode register 1 (input mode)"] +pub struct CCMR1_INPUT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare mode register 1 (input mode)"] +pub mod ccmr1_input; +#[doc = "capture/compare enable register"] +pub struct CCER { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare enable register"] +pub mod ccer; +#[doc = "counter"] +pub struct CNT { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "counter"] +pub mod cnt; +#[doc = "prescaler"] +pub struct PSC { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "prescaler"] +pub mod psc; +#[doc = "auto-reload register"] +pub struct ARR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "auto-reload register"] +pub mod arr; +#[doc = "capture/compare register 1"] +pub struct CCR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 1"] +pub mod ccr1; +#[doc = "capture/compare register 2"] +pub struct CCR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "capture/compare register 2"] +pub mod ccr2; diff --git a/src/tim9/psc/mod.rs b/src/tim9/psc/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..1836ac18054121e612541e5e6f069b50bc6b2f8e --- /dev/null +++ b/src/tim9/psc/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::PSC { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u16, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u16 = 65535; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:15 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/tim9/smcr/mod.rs b/src/tim9/smcr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..74704ba697a5627335e3f8917c32bbdc7e540a9e --- /dev/null +++ b/src/tim9/smcr/mod.rs @@ -0,0 +1,205 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SMCR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct MSMR { + bits: bool, +} +impl MSMR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TSR { + bits: u8, +} +impl TSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct SMSR { + bits: u8, +} +impl SMSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _MSMW<'a> { + w: &'a mut W, +} +impl<'a> _MSMW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TSW<'a> { + w: &'a mut W, +} +impl<'a> _TSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SMSW<'a> { + w: &'a mut W, +} +impl<'a> _SMSW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&self) -> MSMR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MSMR { bits } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&self) -> TSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TSR { bits } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&self) -> SMSR { + let bits = { + const MASK: u8 = 7; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + SMSR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Master/Slave mode"] + #[inline] + pub fn msm(&mut self) -> _MSMW { + _MSMW { w: self } + } + #[doc = "Bits 4:6 - Trigger selection"] + #[inline] + pub fn ts(&mut self) -> _TSW { + _TSW { w: self } + } + #[doc = "Bits 0:2 - Slave mode selection"] + #[inline] + pub fn sms(&mut self) -> _SMSW { + _SMSW { w: self } + } +} diff --git a/src/tim9/sr/mod.rs b/src/tim9/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..17340bed81054d3d2d0cd2133efa5bcd4fdda48e --- /dev/null +++ b/src/tim9/sr/mod.rs @@ -0,0 +1,418 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CC2OFR { + bits: bool, +} +impl CC2OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1OFR { + bits: bool, +} +impl CC1OFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TIFR { + bits: bool, +} +impl TIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC2IFR { + bits: bool, +} +impl CC2IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CC1IFR { + bits: bool, +} +impl CC1IFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UIFR { + bits: bool, +} +impl UIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CC2OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1OFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1OFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TIFW<'a> { + w: &'a mut W, +} +impl<'a> _TIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC2IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC2IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CC1IFW<'a> { + w: &'a mut W, +} +impl<'a> _CC1IFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UIFW<'a> { + w: &'a mut W, +} +impl<'a> _UIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&self) -> CC2OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2OFR { bits } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&self) -> CC1OFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1OFR { bits } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&self) -> TIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TIFR { bits } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&self) -> CC2IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC2IFR { bits } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&self) -> CC1IFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CC1IFR { bits } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&self) -> UIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] + #[inline] + pub fn cc2of(&mut self) -> _CC2OFW { + _CC2OFW { w: self } + } + #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] + #[inline] + pub fn cc1of(&mut self) -> _CC1OFW { + _CC1OFW { w: self } + } + #[doc = "Bit 6 - Trigger interrupt flag"] + #[inline] + pub fn tif(&mut self) -> _TIFW { + _TIFW { w: self } + } + #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] + #[inline] + pub fn cc2if(&mut self) -> _CC2IFW { + _CC2IFW { w: self } + } + #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] + #[inline] + pub fn cc1if(&mut self) -> _CC1IFW { + _CC1IFW { w: self } + } + #[doc = "Bit 0 - Update interrupt flag"] + #[inline] + pub fn uif(&mut self) -> _UIFW { + _UIFW { w: self } + } +} diff --git a/src/usart1/brr/mod.rs b/src/usart1/brr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..b14731d25287288c074754b59bf4c5120a5cf5d9 --- /dev/null +++ b/src/usart1/brr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::BRR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DIV_MANTISSAR { + bits: u16, +} +impl DIV_MANTISSAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct DIV_FRACTIONR { + bits: u8, +} +impl DIV_FRACTIONR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DIV_MANTISSAW<'a> { + w: &'a mut W, +} +impl<'a> _DIV_MANTISSAW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DIV_FRACTIONW<'a> { + w: &'a mut W, +} +impl<'a> _DIV_FRACTIONW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 4:15 - mantissa of USARTDIV"] + #[inline] + pub fn div_mantissa(&self) -> DIV_MANTISSAR { + let bits = { + const MASK: u16 = 4095; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DIV_MANTISSAR { bits } + } + #[doc = "Bits 0:3 - fraction of USARTDIV"] + #[inline] + pub fn div_fraction(&self) -> DIV_FRACTIONR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + DIV_FRACTIONR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 4:15 - mantissa of USARTDIV"] + #[inline] + pub fn div_mantissa(&mut self) -> _DIV_MANTISSAW { + _DIV_MANTISSAW { w: self } + } + #[doc = "Bits 0:3 - fraction of USARTDIV"] + #[inline] + pub fn div_fraction(&mut self) -> _DIV_FRACTIONW { + _DIV_FRACTIONW { w: self } + } +} diff --git a/src/usart1/cr1/mod.rs b/src/usart1/cr1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..a2956b54d6fb6fa6542e17efe190a1d29944e228 --- /dev/null +++ b/src/usart1/cr1/mod.rs @@ -0,0 +1,949 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR1 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct OVER8R { + bits: bool, +} +impl OVER8R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct UER { + bits: bool, +} +impl UER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct MR { + bits: bool, +} +impl MR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WAKER { + bits: bool, +} +impl WAKER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PCER { + bits: bool, +} +impl PCER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PSR { + bits: bool, +} +impl PSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PEIER { + bits: bool, +} +impl PEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXEIER { + bits: bool, +} +impl TXEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCIER { + bits: bool, +} +impl TCIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNEIER { + bits: bool, +} +impl RXNEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDLEIER { + bits: bool, +} +impl IDLEIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TER { + bits: bool, +} +impl TER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RER { + bits: bool, +} +impl RER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RWUR { + bits: bool, +} +impl RWUR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SBKR { + bits: bool, +} +impl SBKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _OVER8W<'a> { + w: &'a mut W, +} +impl<'a> _OVER8W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 15; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _UEW<'a> { + w: &'a mut W, +} +impl<'a> _UEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 13; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _MW<'a> { + w: &'a mut W, +} +impl<'a> _MW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WAKEW<'a> { + w: &'a mut W, +} +impl<'a> _WAKEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PCEW<'a> { + w: &'a mut W, +} +impl<'a> _PCEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSW<'a> { + w: &'a mut W, +} +impl<'a> _PSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PEIEW<'a> { + w: &'a mut W, +} +impl<'a> _PEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TXEIEW<'a> { + w: &'a mut W, +} +impl<'a> _TXEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCIEW<'a> { + w: &'a mut W, +} +impl<'a> _TCIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXNEIEW<'a> { + w: &'a mut W, +} +impl<'a> _RXNEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IDLEIEW<'a> { + w: &'a mut W, +} +impl<'a> _IDLEIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TEW<'a> { + w: &'a mut W, +} +impl<'a> _TEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _REW<'a> { + w: &'a mut W, +} +impl<'a> _REW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RWUW<'a> { + w: &'a mut W, +} +impl<'a> _RWUW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SBKW<'a> { + w: &'a mut W, +} +impl<'a> _SBKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 15 - Oversampling mode"] + #[inline] + pub fn over8(&self) -> OVER8R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 15; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + OVER8R { bits } + } + #[doc = "Bit 13 - USART enable"] + #[inline] + pub fn ue(&self) -> UER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 13; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + UER { bits } + } + #[doc = "Bit 12 - Word length"] + #[inline] + pub fn m(&self) -> MR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + MR { bits } + } + #[doc = "Bit 11 - Wakeup method"] + #[inline] + pub fn wake(&self) -> WAKER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WAKER { bits } + } + #[doc = "Bit 10 - Parity control enable"] + #[inline] + pub fn pce(&self) -> PCER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PCER { bits } + } + #[doc = "Bit 9 - Parity selection"] + #[inline] + pub fn ps(&self) -> PSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PSR { bits } + } + #[doc = "Bit 8 - PE interrupt enable"] + #[inline] + pub fn peie(&self) -> PEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PEIER { bits } + } + #[doc = "Bit 7 - TXE interrupt enable"] + #[inline] + pub fn txeie(&self) -> TXEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXEIER { bits } + } + #[doc = "Bit 6 - Transmission complete interrupt enable"] + #[inline] + pub fn tcie(&self) -> TCIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCIER { bits } + } + #[doc = "Bit 5 - RXNE interrupt enable"] + #[inline] + pub fn rxneie(&self) -> RXNEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNEIER { bits } + } + #[doc = "Bit 4 - IDLE interrupt enable"] + #[inline] + pub fn idleie(&self) -> IDLEIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDLEIER { bits } + } + #[doc = "Bit 3 - Transmitter enable"] + #[inline] + pub fn te(&self) -> TER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TER { bits } + } + #[doc = "Bit 2 - Receiver enable"] + #[inline] + pub fn re(&self) -> RER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RER { bits } + } + #[doc = "Bit 1 - Receiver wakeup"] + #[inline] + pub fn rwu(&self) -> RWUR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RWUR { bits } + } + #[doc = "Bit 0 - Send break"] + #[inline] + pub fn sbk(&self) -> SBKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SBKR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 15 - Oversampling mode"] + #[inline] + pub fn over8(&mut self) -> _OVER8W { + _OVER8W { w: self } + } + #[doc = "Bit 13 - USART enable"] + #[inline] + pub fn ue(&mut self) -> _UEW { + _UEW { w: self } + } + #[doc = "Bit 12 - Word length"] + #[inline] + pub fn m(&mut self) -> _MW { + _MW { w: self } + } + #[doc = "Bit 11 - Wakeup method"] + #[inline] + pub fn wake(&mut self) -> _WAKEW { + _WAKEW { w: self } + } + #[doc = "Bit 10 - Parity control enable"] + #[inline] + pub fn pce(&mut self) -> _PCEW { + _PCEW { w: self } + } + #[doc = "Bit 9 - Parity selection"] + #[inline] + pub fn ps(&mut self) -> _PSW { + _PSW { w: self } + } + #[doc = "Bit 8 - PE interrupt enable"] + #[inline] + pub fn peie(&mut self) -> _PEIEW { + _PEIEW { w: self } + } + #[doc = "Bit 7 - TXE interrupt enable"] + #[inline] + pub fn txeie(&mut self) -> _TXEIEW { + _TXEIEW { w: self } + } + #[doc = "Bit 6 - Transmission complete interrupt enable"] + #[inline] + pub fn tcie(&mut self) -> _TCIEW { + _TCIEW { w: self } + } + #[doc = "Bit 5 - RXNE interrupt enable"] + #[inline] + pub fn rxneie(&mut self) -> _RXNEIEW { + _RXNEIEW { w: self } + } + #[doc = "Bit 4 - IDLE interrupt enable"] + #[inline] + pub fn idleie(&mut self) -> _IDLEIEW { + _IDLEIEW { w: self } + } + #[doc = "Bit 3 - Transmitter enable"] + #[inline] + pub fn te(&mut self) -> _TEW { + _TEW { w: self } + } + #[doc = "Bit 2 - Receiver enable"] + #[inline] + pub fn re(&mut self) -> _REW { + _REW { w: self } + } + #[doc = "Bit 1 - Receiver wakeup"] + #[inline] + pub fn rwu(&mut self) -> _RWUW { + _RWUW { w: self } + } + #[doc = "Bit 0 - Send break"] + #[inline] + pub fn sbk(&mut self) -> _SBKW { + _SBKW { w: self } + } +} diff --git a/src/usart1/cr2/mod.rs b/src/usart1/cr2/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..0237048a5f99690fd945844e18cde623595e28e2 --- /dev/null +++ b/src/usart1/cr2/mod.rs @@ -0,0 +1,559 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR2 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct LINENR { + bits: bool, +} +impl LINENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct STOPR { + bits: u8, +} +impl STOPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct CLKENR { + bits: bool, +} +impl CLKENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CPOLR { + bits: bool, +} +impl CPOLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CPHAR { + bits: bool, +} +impl CPHAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LBCLR { + bits: bool, +} +impl LBCLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LBDIER { + bits: bool, +} +impl LBDIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LBDLR { + bits: bool, +} +impl LBDLR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ADDR { + bits: u8, +} +impl ADDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _LINENW<'a> { + w: &'a mut W, +} +impl<'a> _LINENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 14; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _STOPW<'a> { + w: &'a mut W, +} +impl<'a> _STOPW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CLKENW<'a> { + w: &'a mut W, +} +impl<'a> _CLKENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPOLW<'a> { + w: &'a mut W, +} +impl<'a> _CPOLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CPHAW<'a> { + w: &'a mut W, +} +impl<'a> _CPHAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LBCLW<'a> { + w: &'a mut W, +} +impl<'a> _LBCLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LBDIEW<'a> { + w: &'a mut W, +} +impl<'a> _LBDIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LBDLW<'a> { + w: &'a mut W, +} +impl<'a> _LBDLW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _ADDW<'a> { + w: &'a mut W, +} +impl<'a> _ADDW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 14 - LIN mode enable"] + #[inline] + pub fn linen(&self) -> LINENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 14; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LINENR { bits } + } + #[doc = "Bits 12:13 - STOP bits"] + #[inline] + pub fn stop(&self) -> STOPR { + let bits = { + const MASK: u8 = 3; + const OFFSET: u8 = 12; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + STOPR { bits } + } + #[doc = "Bit 11 - Clock enable"] + #[inline] + pub fn clken(&self) -> CLKENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CLKENR { bits } + } + #[doc = "Bit 10 - Clock polarity"] + #[inline] + pub fn cpol(&self) -> CPOLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPOLR { bits } + } + #[doc = "Bit 9 - Clock phase"] + #[inline] + pub fn cpha(&self) -> CPHAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CPHAR { bits } + } + #[doc = "Bit 8 - Last bit clock pulse"] + #[inline] + pub fn lbcl(&self) -> LBCLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LBCLR { bits } + } + #[doc = "Bit 6 - LIN break detection interrupt enable"] + #[inline] + pub fn lbdie(&self) -> LBDIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LBDIER { bits } + } + #[doc = "Bit 5 - lin break detection length"] + #[inline] + pub fn lbdl(&self) -> LBDLR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LBDLR { bits } + } + #[doc = "Bits 0:3 - Address of the USART node"] + #[inline] + pub fn add(&self) -> ADDR { + let bits = { + const MASK: u8 = 15; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + ADDR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 14 - LIN mode enable"] + #[inline] + pub fn linen(&mut self) -> _LINENW { + _LINENW { w: self } + } + #[doc = "Bits 12:13 - STOP bits"] + #[inline] + pub fn stop(&mut self) -> _STOPW { + _STOPW { w: self } + } + #[doc = "Bit 11 - Clock enable"] + #[inline] + pub fn clken(&mut self) -> _CLKENW { + _CLKENW { w: self } + } + #[doc = "Bit 10 - Clock polarity"] + #[inline] + pub fn cpol(&mut self) -> _CPOLW { + _CPOLW { w: self } + } + #[doc = "Bit 9 - Clock phase"] + #[inline] + pub fn cpha(&mut self) -> _CPHAW { + _CPHAW { w: self } + } + #[doc = "Bit 8 - Last bit clock pulse"] + #[inline] + pub fn lbcl(&mut self) -> _LBCLW { + _LBCLW { w: self } + } + #[doc = "Bit 6 - LIN break detection interrupt enable"] + #[inline] + pub fn lbdie(&mut self) -> _LBDIEW { + _LBDIEW { w: self } + } + #[doc = "Bit 5 - lin break detection length"] + #[inline] + pub fn lbdl(&mut self) -> _LBDLW { + _LBDLW { w: self } + } + #[doc = "Bits 0:3 - Address of the USART node"] + #[inline] + pub fn add(&mut self) -> _ADDW { + _ADDW { w: self } + } +} diff --git a/src/usart1/cr3/mod.rs b/src/usart1/cr3/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..ae0fdaad4c9db88b0ffc68ee9af3cfdd9498b1e4 --- /dev/null +++ b/src/usart1/cr3/mod.rs @@ -0,0 +1,772 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR3 { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct ONEBITR { + bits: bool, +} +impl ONEBITR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTSIER { + bits: bool, +} +impl CTSIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct CTSER { + bits: bool, +} +impl CTSER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RTSER { + bits: bool, +} +impl RTSER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMATR { + bits: bool, +} +impl DMATR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct DMARR { + bits: bool, +} +impl DMARR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct SCENR { + bits: bool, +} +impl SCENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NACKR { + bits: bool, +} +impl NACKR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct HDSELR { + bits: bool, +} +impl HDSELR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRLPR { + bits: bool, +} +impl IRLPR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IRENR { + bits: bool, +} +impl IRENR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct EIER { + bits: bool, +} +impl EIER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _ONEBITW<'a> { + w: &'a mut W, +} +impl<'a> _ONEBITW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 11; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTSIEW<'a> { + w: &'a mut W, +} +impl<'a> _CTSIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 10; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _CTSEW<'a> { + w: &'a mut W, +} +impl<'a> _CTSEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RTSEW<'a> { + w: &'a mut W, +} +impl<'a> _RTSEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMATW<'a> { + w: &'a mut W, +} +impl<'a> _DMATW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _DMARW<'a> { + w: &'a mut W, +} +impl<'a> _DMARW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _SCENW<'a> { + w: &'a mut W, +} +impl<'a> _SCENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _NACKW<'a> { + w: &'a mut W, +} +impl<'a> _NACKW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 4; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _HDSELW<'a> { + w: &'a mut W, +} +impl<'a> _HDSELW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 3; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRLPW<'a> { + w: &'a mut W, +} +impl<'a> _IRLPW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 2; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _IRENW<'a> { + w: &'a mut W, +} +impl<'a> _IRENW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 1; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _EIEW<'a> { + w: &'a mut W, +} +impl<'a> _EIEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 11 - One sample bit method enable"] + #[inline] + pub fn onebit(&self) -> ONEBITR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 11; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ONEBITR { bits } + } + #[doc = "Bit 10 - CTS interrupt enable"] + #[inline] + pub fn ctsie(&self) -> CTSIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 10; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTSIER { bits } + } + #[doc = "Bit 9 - CTS enable"] + #[inline] + pub fn ctse(&self) -> CTSER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTSER { bits } + } + #[doc = "Bit 8 - RTS enable"] + #[inline] + pub fn rtse(&self) -> RTSER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RTSER { bits } + } + #[doc = "Bit 7 - DMA enable transmitter"] + #[inline] + pub fn dmat(&self) -> DMATR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMATR { bits } + } + #[doc = "Bit 6 - DMA enable receiver"] + #[inline] + pub fn dmar(&self) -> DMARR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + DMARR { bits } + } + #[doc = "Bit 5 - Smartcard mode enable"] + #[inline] + pub fn scen(&self) -> SCENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + SCENR { bits } + } + #[doc = "Bit 4 - Smartcard NACK enable"] + #[inline] + pub fn nack(&self) -> NACKR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NACKR { bits } + } + #[doc = "Bit 3 - Half-duplex selection"] + #[inline] + pub fn hdsel(&self) -> HDSELR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + HDSELR { bits } + } + #[doc = "Bit 2 - IrDA low-power"] + #[inline] + pub fn irlp(&self) -> IRLPR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRLPR { bits } + } + #[doc = "Bit 1 - IrDA mode enable"] + #[inline] + pub fn iren(&self) -> IRENR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IRENR { bits } + } + #[doc = "Bit 0 - Error interrupt enable"] + #[inline] + pub fn eie(&self) -> EIER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EIER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 11 - One sample bit method enable"] + #[inline] + pub fn onebit(&mut self) -> _ONEBITW { + _ONEBITW { w: self } + } + #[doc = "Bit 10 - CTS interrupt enable"] + #[inline] + pub fn ctsie(&mut self) -> _CTSIEW { + _CTSIEW { w: self } + } + #[doc = "Bit 9 - CTS enable"] + #[inline] + pub fn ctse(&mut self) -> _CTSEW { + _CTSEW { w: self } + } + #[doc = "Bit 8 - RTS enable"] + #[inline] + pub fn rtse(&mut self) -> _RTSEW { + _RTSEW { w: self } + } + #[doc = "Bit 7 - DMA enable transmitter"] + #[inline] + pub fn dmat(&mut self) -> _DMATW { + _DMATW { w: self } + } + #[doc = "Bit 6 - DMA enable receiver"] + #[inline] + pub fn dmar(&mut self) -> _DMARW { + _DMARW { w: self } + } + #[doc = "Bit 5 - Smartcard mode enable"] + #[inline] + pub fn scen(&mut self) -> _SCENW { + _SCENW { w: self } + } + #[doc = "Bit 4 - Smartcard NACK enable"] + #[inline] + pub fn nack(&mut self) -> _NACKW { + _NACKW { w: self } + } + #[doc = "Bit 3 - Half-duplex selection"] + #[inline] + pub fn hdsel(&mut self) -> _HDSELW { + _HDSELW { w: self } + } + #[doc = "Bit 2 - IrDA low-power"] + #[inline] + pub fn irlp(&mut self) -> _IRLPW { + _IRLPW { w: self } + } + #[doc = "Bit 1 - IrDA mode enable"] + #[inline] + pub fn iren(&mut self) -> _IRENW { + _IRENW { w: self } + } + #[doc = "Bit 0 - Error interrupt enable"] + #[inline] + pub fn eie(&mut self) -> _EIEW { + _EIEW { w: self } + } +} diff --git a/src/usart1/dr/mod.rs b/src/usart1/dr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..840a76429ea925a44648b31c3871242e1f1d797f --- /dev/null +++ b/src/usart1/dr/mod.rs @@ -0,0 +1,105 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::DR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct DRR { + bits: u16, +} +impl DRR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u16 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _DRW<'a> { + w: &'a mut W, +} +impl<'a> _DRW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u16) -> &'a mut W { + const MASK: u16 = 511; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 0:8 - Data value"] + #[inline] + pub fn dr(&self) -> DRR { + let bits = { + const MASK: u16 = 511; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u16 + }; + DRR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 0:8 - Data value"] + #[inline] + pub fn dr(&mut self) -> _DRW { + _DRW { w: self } + } +} diff --git a/src/usart1/gtpr/mod.rs b/src/usart1/gtpr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e80062483be5dfa5ef9d9d6df0f25f3800d6e1d0 --- /dev/null +++ b/src/usart1/gtpr/mod.rs @@ -0,0 +1,146 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::GTPR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct GTR { + bits: u8, +} +impl GTR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Value of the field"] +pub struct PSCR { + bits: u8, +} +impl PSCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _GTW<'a> { + w: &'a mut W, +} +impl<'a> _GTW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _PSCW<'a> { + w: &'a mut W, +} +impl<'a> _PSCW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bits 8:15 - Guard time value"] + #[inline] + pub fn gt(&self) -> GTR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + GTR { bits } + } + #[doc = "Bits 0:7 - Prescaler value"] + #[inline] + pub fn psc(&self) -> PSCR { + let bits = { + const MASK: u8 = 255; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + PSCR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bits 8:15 - Guard time value"] + #[inline] + pub fn gt(&mut self) -> _GTW { + _GTW { w: self } + } + #[doc = "Bits 0:7 - Prescaler value"] + #[inline] + pub fn psc(&mut self) -> _PSCW { + _PSCW { w: self } + } +} diff --git a/src/usart1/mod.rs b/src/usart1/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..394f9282c31f9cd26ebacc87e4d58c6c83fdb4ac --- /dev/null +++ b/src/usart1/mod.rs @@ -0,0 +1,60 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Status register"] + pub sr: SR, + #[doc = "0x04 - Data register"] + pub dr: DR, + #[doc = "0x08 - Baud rate register"] + pub brr: BRR, + #[doc = "0x0c - Control register 1"] + pub cr1: CR1, + #[doc = "0x10 - Control register 2"] + pub cr2: CR2, + #[doc = "0x14 - Control register 3"] + pub cr3: CR3, + #[doc = "0x18 - Guard time and prescaler register"] + pub gtpr: GTPR, +} +#[doc = "Status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register"] +pub mod sr; +#[doc = "Data register"] +pub struct DR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Data register"] +pub mod dr; +#[doc = "Baud rate register"] +pub struct BRR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Baud rate register"] +pub mod brr; +#[doc = "Control register 1"] +pub struct CR1 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 1"] +pub mod cr1; +#[doc = "Control register 2"] +pub struct CR2 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 2"] +pub mod cr2; +#[doc = "Control register 3"] +pub struct CR3 { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register 3"] +pub mod cr3; +#[doc = "Guard time and prescaler register"] +pub struct GTPR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Guard time and prescaler register"] +pub mod gtpr; diff --git a/src/usart1/sr/mod.rs b/src/usart1/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..e5a0c06f1ea4b4c412e19499f6f3ea60b81d4be8 --- /dev/null +++ b/src/usart1/sr/mod.rs @@ -0,0 +1,486 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct CTSR { + bits: bool, +} +impl CTSR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct LBDR { + bits: bool, +} +impl LBDR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TXER { + bits: bool, +} +impl TXER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TCR { + bits: bool, +} +impl TCR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct RXNER { + bits: bool, +} +impl RXNER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct IDLER { + bits: bool, +} +impl IDLER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct ORER { + bits: bool, +} +impl ORER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct NFR { + bits: bool, +} +impl NFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct FER { + bits: bool, +} +impl FER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct PER { + bits: bool, +} +impl PER { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _CTSW<'a> { + w: &'a mut W, +} +impl<'a> _CTSW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _LBDW<'a> { + w: &'a mut W, +} +impl<'a> _LBDW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TCW<'a> { + w: &'a mut W, +} +impl<'a> _TCW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 6; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _RXNEW<'a> { + w: &'a mut W, +} +impl<'a> _RXNEW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 5; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - CTS flag"] + #[inline] + pub fn cts(&self) -> CTSR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + CTSR { bits } + } + #[doc = "Bit 8 - LIN break detection flag"] + #[inline] + pub fn lbd(&self) -> LBDR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + LBDR { bits } + } + #[doc = "Bit 7 - Transmit data register empty"] + #[inline] + pub fn txe(&self) -> TXER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TXER { bits } + } + #[doc = "Bit 6 - Transmission complete"] + #[inline] + pub fn tc(&self) -> TCR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 6; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + TCR { bits } + } + #[doc = "Bit 5 - Read data register not empty"] + #[inline] + pub fn rxne(&self) -> RXNER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 5; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + RXNER { bits } + } + #[doc = "Bit 4 - IDLE line detected"] + #[inline] + pub fn idle(&self) -> IDLER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 4; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + IDLER { bits } + } + #[doc = "Bit 3 - Overrun error"] + #[inline] + pub fn ore(&self) -> ORER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 3; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + ORER { bits } + } + #[doc = "Bit 2 - Noise detected flag"] + #[inline] + pub fn nf(&self) -> NFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 2; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + NFR { bits } + } + #[doc = "Bit 1 - Framing error"] + #[inline] + pub fn fe(&self) -> FER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 1; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + FER { bits } + } + #[doc = "Bit 0 - Parity error"] + #[inline] + pub fn pe(&self) -> PER { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + PER { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 12582912 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - CTS flag"] + #[inline] + pub fn cts(&mut self) -> _CTSW { + _CTSW { w: self } + } + #[doc = "Bit 8 - LIN break detection flag"] + #[inline] + pub fn lbd(&mut self) -> _LBDW { + _LBDW { w: self } + } + #[doc = "Bit 6 - Transmission complete"] + #[inline] + pub fn tc(&mut self) -> _TCW { + _TCW { w: self } + } + #[doc = "Bit 5 - Read data register not empty"] + #[inline] + pub fn rxne(&mut self) -> _RXNEW { + _RXNEW { w: self } + } +} diff --git a/src/wwdg/cfr/mod.rs b/src/wwdg/cfr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..aa59f6774ba9962f886262aa3ea6a34ddbc7350d --- /dev/null +++ b/src/wwdg/cfr/mod.rs @@ -0,0 +1,282 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CFR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EWIR { + bits: bool, +} +impl EWIR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WDGTB1R { + bits: bool, +} +impl WDGTB1R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WDGTB0R { + bits: bool, +} +impl WDGTB0R { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct WR { + bits: u8, +} +impl WR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _EWIW<'a> { + w: &'a mut W, +} +impl<'a> _EWIW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 9; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDGTB1W<'a> { + w: &'a mut W, +} +impl<'a> _WDGTB1W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 8; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WDGTB0W<'a> { + w: &'a mut W, +} +impl<'a> _WDGTB0W<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _WW<'a> { + w: &'a mut W, +} +impl<'a> _WW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 9 - Early wakeup interrupt"] + #[inline] + pub fn ewi(&self) -> EWIR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 9; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EWIR { bits } + } + #[doc = "Bit 8 - Timer base"] + #[inline] + pub fn wdgtb1(&self) -> WDGTB1R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 8; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDGTB1R { bits } + } + #[doc = "Bit 7 - Timer base"] + #[inline] + pub fn wdgtb0(&self) -> WDGTB0R { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDGTB0R { bits } + } + #[doc = "Bits 0:6 - 7-bit window value"] + #[inline] + pub fn w(&self) -> WR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + WR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 127 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 9 - Early wakeup interrupt"] + #[inline] + pub fn ewi(&mut self) -> _EWIW { + _EWIW { w: self } + } + #[doc = "Bit 8 - Timer base"] + #[inline] + pub fn wdgtb1(&mut self) -> _WDGTB1W { + _WDGTB1W { w: self } + } + #[doc = "Bit 7 - Timer base"] + #[inline] + pub fn wdgtb0(&mut self) -> _WDGTB0W { + _WDGTB0W { w: self } + } + #[doc = "Bits 0:6 - 7-bit window value"] + #[inline] + pub fn w(&mut self) -> _WW { + _WW { w: self } + } +} diff --git a/src/wwdg/cr/mod.rs b/src/wwdg/cr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..fd8e9db9fa3164cb5dd770ad43400294b7783e18 --- /dev/null +++ b/src/wwdg/cr/mod.rs @@ -0,0 +1,164 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::CR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct WDGAR { + bits: bool, +} +impl WDGAR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Value of the field"] +pub struct TR { + bits: u8, +} +impl TR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bits(&self) -> u8 { + self.bits + } +} +#[doc = r" Proxy"] +pub struct _WDGAW<'a> { + w: &'a mut W, +} +impl<'a> _WDGAW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 7; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +#[doc = r" Proxy"] +pub struct _TW<'a> { + w: &'a mut W, +} +impl<'a> _TW<'a> { + #[doc = r" Writes raw bits to the field"] + #[inline] + pub unsafe fn bits(self, value: u8) -> &'a mut W { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 7 - Activation bit"] + #[inline] + pub fn wdga(&self) -> WDGAR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 7; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + WDGAR { bits } + } + #[doc = "Bits 0:6 - 7-bit counter (MSB to LSB)"] + #[inline] + pub fn t(&self) -> TR { + let bits = { + const MASK: u8 = 127; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) as u8 + }; + TR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 127 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 7 - Activation bit"] + #[inline] + pub fn wdga(&mut self) -> _WDGAW { + _WDGAW { w: self } + } + #[doc = "Bits 0:6 - 7-bit counter (MSB to LSB)"] + #[inline] + pub fn t(&mut self) -> _TW { + _TW { w: self } + } +} diff --git a/src/wwdg/mod.rs b/src/wwdg/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..6298e43bb0abd842a39cc87da2e079b1d1057314 --- /dev/null +++ b/src/wwdg/mod.rs @@ -0,0 +1,28 @@ +#[doc = r" Register block"] +#[repr(C)] +pub struct RegisterBlock { + #[doc = "0x00 - Control register"] + pub cr: CR, + #[doc = "0x04 - Configuration register"] + pub cfr: CFR, + #[doc = "0x08 - Status register"] + pub sr: SR, +} +#[doc = "Control register"] +pub struct CR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Control register"] +pub mod cr; +#[doc = "Configuration register"] +pub struct CFR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Configuration register"] +pub mod cfr; +#[doc = "Status register"] +pub struct SR { + register: ::vcell::VolatileCell<u32>, +} +#[doc = "Status register"] +pub mod sr; diff --git a/src/wwdg/sr/mod.rs b/src/wwdg/sr/mod.rs new file mode 100644 index 0000000000000000000000000000000000000000..cb7386d074d263cc81572684bd24e9dace257049 --- /dev/null +++ b/src/wwdg/sr/mod.rs @@ -0,0 +1,123 @@ +#[doc = r" Value read from the register"] +pub struct R { + bits: u32, +} +#[doc = r" Value to write to the register"] +pub struct W { + bits: u32, +} +impl super::SR { + #[doc = r" Modifies the contents of the register"] + #[inline] + pub fn modify<F>(&self, f: F) + where + for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, + { + let bits = self.register.get(); + let r = R { bits: bits }; + let mut w = W { bits: bits }; + f(&r, &mut w); + self.register.set(w.bits); + } + #[doc = r" Reads the contents of the register"] + #[inline] + pub fn read(&self) -> R { + R { + bits: self.register.get(), + } + } + #[doc = r" Writes to the register"] + #[inline] + pub fn write<F>(&self, f: F) + where + F: FnOnce(&mut W) -> &mut W, + { + let mut w = W::reset_value(); + f(&mut w); + self.register.set(w.bits); + } + #[doc = r" Writes the reset value to the register"] + #[inline] + pub fn reset(&self) { + self.write(|w| w) + } +} +#[doc = r" Value of the field"] +pub struct EWIFR { + bits: bool, +} +impl EWIFR { + #[doc = r" Value of the field as raw bits"] + #[inline] + pub fn bit(&self) -> bool { + self.bits + } + #[doc = r" Returns `true` if the bit is clear (0)"] + #[inline] + pub fn bit_is_clear(&self) -> bool { + !self.bit() + } + #[doc = r" Returns `true` if the bit is set (1)"] + #[inline] + pub fn bit_is_set(&self) -> bool { + self.bit() + } +} +#[doc = r" Proxy"] +pub struct _EWIFW<'a> { + w: &'a mut W, +} +impl<'a> _EWIFW<'a> { + #[doc = r" Sets the field bit"] + pub fn set_bit(self) -> &'a mut W { + self.bit(true) + } + #[doc = r" Clears the field bit"] + pub fn clear_bit(self) -> &'a mut W { + self.bit(false) + } + #[doc = r" Writes raw bits to the field"] + #[inline] + pub fn bit(self, value: bool) -> &'a mut W { + const MASK: bool = true; + const OFFSET: u8 = 0; + self.w.bits &= !((MASK as u32) << OFFSET); + self.w.bits |= ((value & MASK) as u32) << OFFSET; + self.w + } +} +impl R { + #[doc = r" Value of the register as raw bits"] + #[inline] + pub fn bits(&self) -> u32 { + self.bits + } + #[doc = "Bit 0 - Early wakeup interrupt flag"] + #[inline] + pub fn ewif(&self) -> EWIFR { + let bits = { + const MASK: bool = true; + const OFFSET: u8 = 0; + ((self.bits >> OFFSET) & MASK as u32) != 0 + }; + EWIFR { bits } + } +} +impl W { + #[doc = r" Reset value of the register"] + #[inline] + pub fn reset_value() -> W { + W { bits: 0 } + } + #[doc = r" Writes raw bits to the register"] + #[inline] + pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { + self.bits = bits; + self + } + #[doc = "Bit 0 - Early wakeup interrupt flag"] + #[inline] + pub fn ewif(&mut self) -> _EWIFW { + _EWIFW { w: self } + } +}