| #![no_std] |
| #![allow(clippy::erasing_op)] |
| #![allow(clippy::identity_op)] |
| #[doc = r" A zero-sized type that represents ownership of this"] |
| #[doc = r" peripheral, used to get access to a Register lock. Most"] |
| #[doc = r" programs create one of these in unsafe code near the top of"] |
| #[doc = r" main(), and pass it to the driver responsible for managing"] |
| #[doc = r" all access to the hardware."] |
| pub struct ClkmgrAon { |
| _priv: (), |
| } |
| impl ClkmgrAon { |
| pub const PTR: *mut u32 = 0x40420000 as *mut u32; |
| #[doc = r" # Safety"] |
| #[doc = r""] |
| #[doc = r" Caller must ensure that all concurrent use of this"] |
| #[doc = r" peripheral in the firmware is done so in a compatible"] |
| #[doc = r" way. The simplest way to enforce this is to only call"] |
| #[doc = r" this function once."] |
| #[inline(always)] |
| pub const unsafe fn new() -> Self { |
| Self { _priv: () } |
| } |
| #[doc = r" Returns a register block that can be used to read"] |
| #[doc = r" registers from this peripheral, but cannot write."] |
| #[inline(always)] |
| pub fn regs(&self) -> RegisterBlock<ureg::RealMmio<'_>> { |
| RegisterBlock { |
| ptr: Self::PTR, |
| mmio: core::default::Default::default(), |
| } |
| } |
| #[doc = r" Return a register block that can be used to read and"] |
| #[doc = r" write this peripheral's registers."] |
| #[inline(always)] |
| pub fn regs_mut(&mut self) -> RegisterBlock<ureg::RealMmioMut<'_>> { |
| RegisterBlock { |
| ptr: Self::PTR, |
| mmio: core::default::Default::default(), |
| } |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct RegisterBlock<TMmio: ureg::Mmio + core::borrow::Borrow<TMmio>> { |
| ptr: *mut u32, |
| mmio: TMmio, |
| } |
| impl<TMmio: ureg::Mmio + core::default::Default> RegisterBlock<TMmio> { |
| #[doc = r" # Safety"] |
| #[doc = r""] |
| #[doc = r" The caller is responsible for ensuring that ptr is valid for"] |
| #[doc = r" volatile reads and writes at any of the offsets in this register"] |
| #[doc = r" block."] |
| #[inline(always)] |
| pub unsafe fn new(ptr: *mut u32) -> Self { |
| Self { |
| ptr, |
| mmio: core::default::Default::default(), |
| } |
| } |
| } |
| impl<TMmio: ureg::Mmio> RegisterBlock<TMmio> { |
| #[doc = r" # Safety"] |
| #[doc = r""] |
| #[doc = r" The caller is responsible for ensuring that ptr is valid for"] |
| #[doc = r" volatile reads and writes at any of the offsets in this register"] |
| #[doc = r" block."] |
| #[inline(always)] |
| pub unsafe fn new_with_mmio(ptr: *mut u32, mmio: TMmio) -> Self { |
| Self { ptr, mmio } |
| } |
| #[doc = "Alert Test Register\n\nRead value: [`regs::AlertTestReadVal`]; Write value: [`regs::AlertTestWriteVal`]"] |
| #[inline(always)] |
| pub fn alert_test(&self) -> ureg::RegRef<crate::meta::AlertTest, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Alert Test Register\n\nRead value: [`regs::AlertTestReadVal`]; Write value: [`regs::AlertTestWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_alert_test(self) -> ureg::RegRef<crate::meta::AlertTest, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "External clock control write enable\n\nRead value: [`regs::ExtclkCtrlRegwenReadVal`]; Write value: [`regs::ExtclkCtrlRegwenWriteVal`]"] |
| #[inline(always)] |
| pub fn extclk_ctrl_regwen(&self) -> ureg::RegRef<crate::meta::ExtclkCtrlRegwen, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(4 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "External clock control write enable\n\nRead value: [`regs::ExtclkCtrlRegwenReadVal`]; Write value: [`regs::ExtclkCtrlRegwenWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_extclk_ctrl_regwen(self) -> ureg::RegRef<crate::meta::ExtclkCtrlRegwen, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(4 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Select external clock\n\nRead value: [`regs::ExtclkCtrlReadVal`]; Write value: [`regs::ExtclkCtrlWriteVal`]"] |
| #[inline(always)] |
| pub fn extclk_ctrl(&self) -> ureg::RegRef<crate::meta::ExtclkCtrl, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(8 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Select external clock\n\nRead value: [`regs::ExtclkCtrlReadVal`]; Write value: [`regs::ExtclkCtrlWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_extclk_ctrl(self) -> ureg::RegRef<crate::meta::ExtclkCtrl, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(8 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Status of requested external clock switch\n\nRead value: [`regs::ExtclkStatusReadVal`]; Write value: [`regs::ExtclkStatusWriteVal`]"] |
| #[inline(always)] |
| pub fn extclk_status(&self) -> ureg::RegRef<crate::meta::ExtclkStatus, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0xc / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Status of requested external clock switch\n\nRead value: [`regs::ExtclkStatusReadVal`]; Write value: [`regs::ExtclkStatusWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_extclk_status(self) -> ureg::RegRef<crate::meta::ExtclkStatus, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0xc / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Jitter write enable\n\nRead value: [`regs::JitterRegwenReadVal`]; Write value: [`regs::JitterRegwenWriteVal`]"] |
| #[inline(always)] |
| pub fn jitter_regwen(&self) -> ureg::RegRef<crate::meta::JitterRegwen, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x10 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Jitter write enable\n\nRead value: [`regs::JitterRegwenReadVal`]; Write value: [`regs::JitterRegwenWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_jitter_regwen(self) -> ureg::RegRef<crate::meta::JitterRegwen, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x10 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable jittery clock\n\nRead value: [`regs::JitterEnableReadVal`]; Write value: [`regs::JitterEnableWriteVal`]"] |
| #[inline(always)] |
| pub fn jitter_enable(&self) -> ureg::RegRef<crate::meta::JitterEnable, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x14 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable jittery clock\n\nRead value: [`regs::JitterEnableReadVal`]; Write value: [`regs::JitterEnableWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_jitter_enable(self) -> ureg::RegRef<crate::meta::JitterEnable, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x14 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Clock enable for software gateable clocks.\nThese clocks are directly controlled by software.\n\nRead value: [`regs::ClkEnablesReadVal`]; Write value: [`regs::ClkEnablesWriteVal`]"] |
| #[inline(always)] |
| pub fn clk_enables(&self) -> ureg::RegRef<crate::meta::ClkEnables, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x18 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Clock enable for software gateable clocks.\nThese clocks are directly controlled by software.\n\nRead value: [`regs::ClkEnablesReadVal`]; Write value: [`regs::ClkEnablesWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_clk_enables(self) -> ureg::RegRef<crate::meta::ClkEnables, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x18 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Clock hint for software gateable transactional clocks during active mode.\nDuring low power mode, all clocks are gated off regardless of the software hint.\n\nTransactional clocks are not fully controlled by software. Instead software provides only a disable hint.\n\nWhen software provides a disable hint, the clock manager checks to see if the associated hardware block is idle.\nIf the hardware block is idle, then the clock is disabled.\nIf the hardware block is not idle, the clock is kept on.\n\nFor the enable case, the software hint is immediately honored and the clock turned on. Hardware does not provide any\nfeedback in this case.\n\nRead value: [`regs::ClkHintsReadVal`]; Write value: [`regs::ClkHintsWriteVal`]"] |
| #[inline(always)] |
| pub fn clk_hints(&self) -> ureg::RegRef<crate::meta::ClkHints, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x1c / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Clock hint for software gateable transactional clocks during active mode.\nDuring low power mode, all clocks are gated off regardless of the software hint.\n\nTransactional clocks are not fully controlled by software. Instead software provides only a disable hint.\n\nWhen software provides a disable hint, the clock manager checks to see if the associated hardware block is idle.\nIf the hardware block is idle, then the clock is disabled.\nIf the hardware block is not idle, the clock is kept on.\n\nFor the enable case, the software hint is immediately honored and the clock turned on. Hardware does not provide any\nfeedback in this case.\n\nRead value: [`regs::ClkHintsReadVal`]; Write value: [`regs::ClkHintsWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_clk_hints(self) -> ureg::RegRef<crate::meta::ClkHints, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x1c / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Since the final state of !!CLK_HINTS is not always determined by software,\nthis register provides read feedback for the current clock state.\n\n\nRead value: [`regs::ClkHintsStatusReadVal`]; Write value: [`regs::ClkHintsStatusWriteVal`]"] |
| #[inline(always)] |
| pub fn clk_hints_status(&self) -> ureg::RegRef<crate::meta::ClkHintsStatus, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x20 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Since the final state of !!CLK_HINTS is not always determined by software,\nthis register provides read feedback for the current clock state.\n\n\nRead value: [`regs::ClkHintsStatusReadVal`]; Write value: [`regs::ClkHintsStatusWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_clk_hints_status(self) -> ureg::RegRef<crate::meta::ClkHintsStatus, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x20 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Measurement control write enable\n\nRead value: [`regs::MeasureCtrlRegwenReadVal`]; Write value: [`regs::MeasureCtrlRegwenWriteVal`]"] |
| #[inline(always)] |
| pub fn measure_ctrl_regwen(&self) -> ureg::RegRef<crate::meta::MeasureCtrlRegwen, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x24 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Measurement control write enable\n\nRead value: [`regs::MeasureCtrlRegwenReadVal`]; Write value: [`regs::MeasureCtrlRegwenWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_measure_ctrl_regwen(self) -> ureg::RegRef<crate::meta::MeasureCtrlRegwen, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x24 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoMeasCtrlEnReadVal`]; Write value: [`regs::IoMeasCtrlEnWriteVal`]"] |
| #[inline(always)] |
| pub fn io_meas_ctrl_en(&self) -> ureg::RegRef<crate::meta::IoMeasCtrlEn, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x28 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoMeasCtrlEnReadVal`]; Write value: [`regs::IoMeasCtrlEnWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_meas_ctrl_en(self) -> ureg::RegRef<crate::meta::IoMeasCtrlEn, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x28 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoMeasCtrlShadowedReadVal`]; Write value: [`regs::IoMeasCtrlShadowedWriteVal`]"] |
| #[inline(always)] |
| pub fn io_meas_ctrl_shadowed(&self) -> ureg::RegRef<crate::meta::IoMeasCtrlShadowed, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x2c / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoMeasCtrlShadowedReadVal`]; Write value: [`regs::IoMeasCtrlShadowedWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_meas_ctrl_shadowed( |
| self, |
| ) -> ureg::RegRef<crate::meta::IoMeasCtrlShadowed, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x2c / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoDiv2MeasCtrlEnReadVal`]; Write value: [`regs::IoDiv2MeasCtrlEnWriteVal`]"] |
| #[inline(always)] |
| pub fn io_div2_meas_ctrl_en(&self) -> ureg::RegRef<crate::meta::IoDiv2MeasCtrlEn, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x30 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoDiv2MeasCtrlEnReadVal`]; Write value: [`regs::IoDiv2MeasCtrlEnWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_div2_meas_ctrl_en(self) -> ureg::RegRef<crate::meta::IoDiv2MeasCtrlEn, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x30 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io_div2 measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoDiv2MeasCtrlShadowedReadVal`]; Write value: [`regs::IoDiv2MeasCtrlShadowedWriteVal`]"] |
| #[inline(always)] |
| pub fn io_div2_meas_ctrl_shadowed( |
| &self, |
| ) -> ureg::RegRef<crate::meta::IoDiv2MeasCtrlShadowed, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x34 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io_div2 measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoDiv2MeasCtrlShadowedReadVal`]; Write value: [`regs::IoDiv2MeasCtrlShadowedWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_div2_meas_ctrl_shadowed( |
| self, |
| ) -> ureg::RegRef<crate::meta::IoDiv2MeasCtrlShadowed, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x34 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoDiv4MeasCtrlEnReadVal`]; Write value: [`regs::IoDiv4MeasCtrlEnWriteVal`]"] |
| #[inline(always)] |
| pub fn io_div4_meas_ctrl_en(&self) -> ureg::RegRef<crate::meta::IoDiv4MeasCtrlEn, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x38 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::IoDiv4MeasCtrlEnReadVal`]; Write value: [`regs::IoDiv4MeasCtrlEnWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_div4_meas_ctrl_en(self) -> ureg::RegRef<crate::meta::IoDiv4MeasCtrlEn, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x38 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io_div4 measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoDiv4MeasCtrlShadowedReadVal`]; Write value: [`regs::IoDiv4MeasCtrlShadowedWriteVal`]"] |
| #[inline(always)] |
| pub fn io_div4_meas_ctrl_shadowed( |
| &self, |
| ) -> ureg::RegRef<crate::meta::IoDiv4MeasCtrlShadowed, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x3c / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Configuration controls for io_div4 measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::IoDiv4MeasCtrlShadowedReadVal`]; Write value: [`regs::IoDiv4MeasCtrlShadowedWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_io_div4_meas_ctrl_shadowed( |
| self, |
| ) -> ureg::RegRef<crate::meta::IoDiv4MeasCtrlShadowed, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x3c / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::MainMeasCtrlEnReadVal`]; Write value: [`regs::MainMeasCtrlEnWriteVal`]"] |
| #[inline(always)] |
| pub fn main_meas_ctrl_en(&self) -> ureg::RegRef<crate::meta::MainMeasCtrlEn, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x40 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::MainMeasCtrlEnReadVal`]; Write value: [`regs::MainMeasCtrlEnWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_main_meas_ctrl_en(self) -> ureg::RegRef<crate::meta::MainMeasCtrlEn, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x40 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Configuration controls for main measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::MainMeasCtrlShadowedReadVal`]; Write value: [`regs::MainMeasCtrlShadowedWriteVal`]"] |
| #[inline(always)] |
| pub fn main_meas_ctrl_shadowed( |
| &self, |
| ) -> ureg::RegRef<crate::meta::MainMeasCtrlShadowed, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x44 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Configuration controls for main measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::MainMeasCtrlShadowedReadVal`]; Write value: [`regs::MainMeasCtrlShadowedWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_main_meas_ctrl_shadowed( |
| self, |
| ) -> ureg::RegRef<crate::meta::MainMeasCtrlShadowed, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x44 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::UsbMeasCtrlEnReadVal`]; Write value: [`regs::UsbMeasCtrlEnWriteVal`]"] |
| #[inline(always)] |
| pub fn usb_meas_ctrl_en(&self) -> ureg::RegRef<crate::meta::UsbMeasCtrlEn, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x48 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Enable for measurement control\n\nRead value: [`regs::UsbMeasCtrlEnReadVal`]; Write value: [`regs::UsbMeasCtrlEnWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_usb_meas_ctrl_en(self) -> ureg::RegRef<crate::meta::UsbMeasCtrlEn, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x48 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Configuration controls for usb measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::UsbMeasCtrlShadowedReadVal`]; Write value: [`regs::UsbMeasCtrlShadowedWriteVal`]"] |
| #[inline(always)] |
| pub fn usb_meas_ctrl_shadowed(&self) -> ureg::RegRef<crate::meta::UsbMeasCtrlShadowed, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x4c / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Configuration controls for usb measurement.\n\nThe threshold fields are made wider than required (by 1 bit) to ensure\nthere is room to adjust for measurement inaccuracies.\n\nRead value: [`regs::UsbMeasCtrlShadowedReadVal`]; Write value: [`regs::UsbMeasCtrlShadowedWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_usb_meas_ctrl_shadowed( |
| self, |
| ) -> ureg::RegRef<crate::meta::UsbMeasCtrlShadowed, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x4c / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Recoverable Error code\n\nRead value: [`regs::RecovErrCodeReadVal`]; Write value: [`regs::RecovErrCodeWriteVal`]"] |
| #[inline(always)] |
| pub fn recov_err_code(&self) -> ureg::RegRef<crate::meta::RecovErrCode, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x50 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Recoverable Error code\n\nRead value: [`regs::RecovErrCodeReadVal`]; Write value: [`regs::RecovErrCodeWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_recov_err_code(self) -> ureg::RegRef<crate::meta::RecovErrCode, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x50 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| #[doc = "Error code\n\nRead value: [`regs::FatalErrCodeReadVal`]; Write value: [`regs::FatalErrCodeWriteVal`]"] |
| #[inline(always)] |
| pub fn fatal_err_code(&self) -> ureg::RegRef<crate::meta::FatalErrCode, &TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x54 / core::mem::size_of::<u32>()), |
| core::borrow::Borrow::borrow(&self.mmio), |
| ) |
| } |
| } |
| #[doc = "Error code\n\nRead value: [`regs::FatalErrCodeReadVal`]; Write value: [`regs::FatalErrCodeWriteVal`]"] |
| #[doc = "This function consumes the entire register block, which is useful when transferring ownership."] |
| #[inline(always)] |
| pub fn into_fatal_err_code(self) -> ureg::RegRef<crate::meta::FatalErrCode, TMmio> { |
| unsafe { |
| ureg::RegRef::new_with_mmio( |
| self.ptr.wrapping_add(0x54 / core::mem::size_of::<u32>()), |
| self.mmio, |
| ) |
| } |
| } |
| } |
| pub mod regs { |
| #![doc = r" Types that represent the values held by registers."] |
| #[derive(Clone, Copy)] |
| pub struct AlertTestWriteVal(pub u32); |
| impl AlertTestWriteVal { |
| #[doc = "Write 1 to trigger one alert event of this kind."] |
| #[inline(always)] |
| pub const fn recov_fault(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 0)) | (val as u32) << 0) |
| } |
| #[doc = "Write 1 to trigger one alert event of this kind."] |
| #[inline(always)] |
| pub const fn fatal_fault(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 1)) | (val as u32) << 1) |
| } |
| } |
| impl From<u32> for AlertTestWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<AlertTestWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: AlertTestWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ClkEnablesReadVal(pub u32); |
| impl ClkEnablesReadVal { |
| #[doc = "0 CLK_IO_DIV4_PERI is disabled.\n1 CLK_IO_DIV4_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_div4_peri_en(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = "0 CLK_IO_DIV2_PERI is disabled.\n1 CLK_IO_DIV2_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_div2_peri_en(&self) -> bool { |
| ((self.0 >> 1) & 1) != 0 |
| } |
| #[doc = "0 CLK_IO_PERI is disabled.\n1 CLK_IO_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_peri_en(&self) -> bool { |
| ((self.0 >> 2) & 1) != 0 |
| } |
| #[doc = "0 CLK_USB_PERI is disabled.\n1 CLK_USB_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_usb_peri_en(&self) -> bool { |
| ((self.0 >> 3) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> ClkEnablesWriteVal { |
| ClkEnablesWriteVal(self.0) |
| } |
| } |
| impl From<u32> for ClkEnablesReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ClkEnablesReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ClkEnablesReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ClkEnablesWriteVal(pub u32); |
| impl ClkEnablesWriteVal { |
| #[doc = "0 CLK_IO_DIV4_PERI is disabled.\n1 CLK_IO_DIV4_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_div4_peri_en(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 0)) | (val as u32) << 0) |
| } |
| #[doc = "0 CLK_IO_DIV2_PERI is disabled.\n1 CLK_IO_DIV2_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_div2_peri_en(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 1)) | (val as u32) << 1) |
| } |
| #[doc = "0 CLK_IO_PERI is disabled.\n1 CLK_IO_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_io_peri_en(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 2)) | (val as u32) << 2) |
| } |
| #[doc = "0 CLK_USB_PERI is disabled.\n1 CLK_USB_PERI is enabled."] |
| #[inline(always)] |
| pub const fn clk_usb_peri_en(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 3)) | (val as u32) << 3) |
| } |
| } |
| impl From<u32> for ClkEnablesWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ClkEnablesWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: ClkEnablesWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ClkHintsReadVal(pub u32); |
| impl ClkHintsReadVal { |
| #[doc = "0 CLK_MAIN_AES can be disabled.\n1 CLK_MAIN_AES is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_aes_hint(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_HMAC can be disabled.\n1 CLK_MAIN_HMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_hmac_hint(&self) -> bool { |
| ((self.0 >> 1) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_KMAC can be disabled.\n1 CLK_MAIN_KMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_kmac_hint(&self) -> bool { |
| ((self.0 >> 2) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_OTBN can be disabled.\n1 CLK_MAIN_OTBN is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_otbn_hint(&self) -> bool { |
| ((self.0 >> 3) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> ClkHintsWriteVal { |
| ClkHintsWriteVal(self.0) |
| } |
| } |
| impl From<u32> for ClkHintsReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ClkHintsReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ClkHintsReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ClkHintsWriteVal(pub u32); |
| impl ClkHintsWriteVal { |
| #[doc = "0 CLK_MAIN_AES can be disabled.\n1 CLK_MAIN_AES is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_aes_hint(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 0)) | (val as u32) << 0) |
| } |
| #[doc = "0 CLK_MAIN_HMAC can be disabled.\n1 CLK_MAIN_HMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_hmac_hint(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 1)) | (val as u32) << 1) |
| } |
| #[doc = "0 CLK_MAIN_KMAC can be disabled.\n1 CLK_MAIN_KMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_kmac_hint(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 2)) | (val as u32) << 2) |
| } |
| #[doc = "0 CLK_MAIN_OTBN can be disabled.\n1 CLK_MAIN_OTBN is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_otbn_hint(self, val: bool) -> Self { |
| Self((self.0 & !(1 << 3)) | (val as u32) << 3) |
| } |
| } |
| impl From<u32> for ClkHintsWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ClkHintsWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: ClkHintsWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ClkHintsStatusReadVal(pub u32); |
| impl ClkHintsStatusReadVal { |
| #[doc = "0 CLK_MAIN_AES is disabled.\n1 CLK_MAIN_AES is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_aes_val(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_HMAC is disabled.\n1 CLK_MAIN_HMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_hmac_val(&self) -> bool { |
| ((self.0 >> 1) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_KMAC is disabled.\n1 CLK_MAIN_KMAC is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_kmac_val(&self) -> bool { |
| ((self.0 >> 2) & 1) != 0 |
| } |
| #[doc = "0 CLK_MAIN_OTBN is disabled.\n1 CLK_MAIN_OTBN is enabled."] |
| #[inline(always)] |
| pub const fn clk_main_otbn_val(&self) -> bool { |
| ((self.0 >> 3) & 1) != 0 |
| } |
| } |
| impl From<u32> for ClkHintsStatusReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ClkHintsStatusReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ClkHintsStatusReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ExtclkCtrlReadVal(pub u32); |
| impl ExtclkCtrlReadVal { |
| #[doc = "When the current value is not kMultiBitBool4True, writing a value of kMultiBitBool4True\nselects external clock as clock for the system. Writing any other value has\nno impact.\n\nWhen the current value is kMultiBitBool4True, writing a value of kMultiBitBool4False\nselects internal clock as clock for the system. Writing any other value during this stage\nhas no impact.\n\nWhile this register can always be programmed, it only takes effect when debug functions are enabled\nin life cycle TEST, DEV or RMA states."] |
| #[inline(always)] |
| pub const fn sel(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = "A value of kMultiBitBool4True selects nominal speed external clock.\nAll other values selects low speed clocks.\n\nNote this field only has an effect when the !!EXTCLK_CTRL.SEL field is set to\nkMultiBitBool4True.\n\nNominal speed means the external clock is approximately the same frequency as\nthe internal oscillator source. When this option is used, all clocks operate\nat roughly the nominal frequency.\n\nLow speed means the external clock is approximately half the frequency of the\ninternal oscillator source. When this option is used, the internal dividers are\nstepped down. As a result, previously undivided clocks now run at half frequency,\nwhile previously divided clocks run at roughly the nominal frequency.\n\nSee external clock switch support in documentation for more details."] |
| #[inline(always)] |
| pub const fn hi_speed_sel(&self) -> u32 { |
| (self.0 >> 4) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> ExtclkCtrlWriteVal { |
| ExtclkCtrlWriteVal(self.0) |
| } |
| } |
| impl From<u32> for ExtclkCtrlReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ExtclkCtrlReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ExtclkCtrlReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ExtclkCtrlWriteVal(pub u32); |
| impl ExtclkCtrlWriteVal { |
| #[doc = "When the current value is not kMultiBitBool4True, writing a value of kMultiBitBool4True\nselects external clock as clock for the system. Writing any other value has\nno impact.\n\nWhen the current value is kMultiBitBool4True, writing a value of kMultiBitBool4False\nselects internal clock as clock for the system. Writing any other value during this stage\nhas no impact.\n\nWhile this register can always be programmed, it only takes effect when debug functions are enabled\nin life cycle TEST, DEV or RMA states."] |
| #[inline(always)] |
| pub const fn sel(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| #[doc = "A value of kMultiBitBool4True selects nominal speed external clock.\nAll other values selects low speed clocks.\n\nNote this field only has an effect when the !!EXTCLK_CTRL.SEL field is set to\nkMultiBitBool4True.\n\nNominal speed means the external clock is approximately the same frequency as\nthe internal oscillator source. When this option is used, all clocks operate\nat roughly the nominal frequency.\n\nLow speed means the external clock is approximately half the frequency of the\ninternal oscillator source. When this option is used, the internal dividers are\nstepped down. As a result, previously undivided clocks now run at half frequency,\nwhile previously divided clocks run at roughly the nominal frequency.\n\nSee external clock switch support in documentation for more details."] |
| #[inline(always)] |
| pub const fn hi_speed_sel(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 4)) | ((val & 0xf) << 4)) |
| } |
| } |
| impl From<u32> for ExtclkCtrlWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ExtclkCtrlWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: ExtclkCtrlWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ExtclkCtrlRegwenReadVal(pub u32); |
| impl ExtclkCtrlRegwenReadVal { |
| #[doc = "When 1, the value of !!EXTCLK_CTRL can be set. When 0, writes to !!EXTCLK_CTRL have no\neffect."] |
| #[inline(always)] |
| pub const fn en(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> ExtclkCtrlRegwenWriteVal { |
| ExtclkCtrlRegwenWriteVal(self.0) |
| } |
| } |
| impl From<u32> for ExtclkCtrlRegwenReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ExtclkCtrlRegwenReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ExtclkCtrlRegwenReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ExtclkCtrlRegwenWriteVal(pub u32); |
| impl ExtclkCtrlRegwenWriteVal { |
| #[doc = "When 1, the value of !!EXTCLK_CTRL can be set. When 0, writes to !!EXTCLK_CTRL have no\neffect."] |
| #[inline(always)] |
| pub const fn en_clear(self) -> Self { |
| Self(self.0 & !(1 << 0)) |
| } |
| } |
| impl From<u32> for ExtclkCtrlRegwenWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ExtclkCtrlRegwenWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: ExtclkCtrlRegwenWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct ExtclkStatusReadVal(pub u32); |
| impl ExtclkStatusReadVal { |
| #[doc = "When !!EXTCLK_CTRL.SEL is set to kMultiBitBool4True, this field reflects\nwhether the clock has been switched the external source.\n\nkMultiBitBool4True indicates the switch is complete.\nkMultiBitBool4False indicates the switch is either not possible or still ongoing."] |
| #[inline(always)] |
| pub const fn ack(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| } |
| impl From<u32> for ExtclkStatusReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<ExtclkStatusReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: ExtclkStatusReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct FatalErrCodeReadVal(pub u32); |
| impl FatalErrCodeReadVal { |
| #[doc = "Register file has experienced a fatal integrity error."] |
| #[inline(always)] |
| pub const fn reg_intg(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = "One of the idle counts encountered a duplicate error."] |
| #[inline(always)] |
| pub const fn idle_cnt(&self) -> bool { |
| ((self.0 >> 1) & 1) != 0 |
| } |
| #[doc = "One of the shadow registers encountered a storage error."] |
| #[inline(always)] |
| pub const fn shadow_storage_err(&self) -> bool { |
| ((self.0 >> 2) & 1) != 0 |
| } |
| } |
| impl From<u32> for FatalErrCodeReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<FatalErrCodeReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: FatalErrCodeReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv2MeasCtrlEnReadVal(pub u32); |
| impl IoDiv2MeasCtrlEnReadVal { |
| #[doc = "Enable measurement for io_div2"] |
| #[inline(always)] |
| pub const fn en(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoDiv2MeasCtrlEnWriteVal { |
| IoDiv2MeasCtrlEnWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoDiv2MeasCtrlEnReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv2MeasCtrlEnReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv2MeasCtrlEnReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv2MeasCtrlEnWriteVal(pub u32); |
| impl IoDiv2MeasCtrlEnWriteVal { |
| #[doc = "Enable measurement for io_div2"] |
| #[inline(always)] |
| pub const fn en(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for IoDiv2MeasCtrlEnWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv2MeasCtrlEnWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv2MeasCtrlEnWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv2MeasCtrlShadowedReadVal(pub u32); |
| impl IoDiv2MeasCtrlShadowedReadVal { |
| #[doc = "Max threshold for io_div2 measurement"] |
| #[inline(always)] |
| pub const fn hi(&self) -> u32 { |
| (self.0 >> 0) & 0x1ff |
| } |
| #[doc = "Min threshold for io_div2 measurement"] |
| #[inline(always)] |
| pub const fn lo(&self) -> u32 { |
| (self.0 >> 9) & 0x1ff |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoDiv2MeasCtrlShadowedWriteVal { |
| IoDiv2MeasCtrlShadowedWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoDiv2MeasCtrlShadowedReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv2MeasCtrlShadowedReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv2MeasCtrlShadowedReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv2MeasCtrlShadowedWriteVal(pub u32); |
| impl IoDiv2MeasCtrlShadowedWriteVal { |
| #[doc = "Max threshold for io_div2 measurement"] |
| #[inline(always)] |
| pub const fn hi(self, val: u32) -> Self { |
| Self((self.0 & !(0x1ff << 0)) | ((val & 0x1ff) << 0)) |
| } |
| #[doc = "Min threshold for io_div2 measurement"] |
| #[inline(always)] |
| pub const fn lo(self, val: u32) -> Self { |
| Self((self.0 & !(0x1ff << 9)) | ((val & 0x1ff) << 9)) |
| } |
| } |
| impl From<u32> for IoDiv2MeasCtrlShadowedWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv2MeasCtrlShadowedWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv2MeasCtrlShadowedWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv4MeasCtrlEnReadVal(pub u32); |
| impl IoDiv4MeasCtrlEnReadVal { |
| #[doc = "Enable measurement for io_div4"] |
| #[inline(always)] |
| pub const fn en(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoDiv4MeasCtrlEnWriteVal { |
| IoDiv4MeasCtrlEnWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoDiv4MeasCtrlEnReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv4MeasCtrlEnReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv4MeasCtrlEnReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv4MeasCtrlEnWriteVal(pub u32); |
| impl IoDiv4MeasCtrlEnWriteVal { |
| #[doc = "Enable measurement for io_div4"] |
| #[inline(always)] |
| pub const fn en(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for IoDiv4MeasCtrlEnWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv4MeasCtrlEnWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv4MeasCtrlEnWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv4MeasCtrlShadowedReadVal(pub u32); |
| impl IoDiv4MeasCtrlShadowedReadVal { |
| #[doc = "Max threshold for io_div4 measurement"] |
| #[inline(always)] |
| pub const fn hi(&self) -> u32 { |
| (self.0 >> 0) & 0xff |
| } |
| #[doc = "Min threshold for io_div4 measurement"] |
| #[inline(always)] |
| pub const fn lo(&self) -> u32 { |
| (self.0 >> 8) & 0xff |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoDiv4MeasCtrlShadowedWriteVal { |
| IoDiv4MeasCtrlShadowedWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoDiv4MeasCtrlShadowedReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv4MeasCtrlShadowedReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv4MeasCtrlShadowedReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoDiv4MeasCtrlShadowedWriteVal(pub u32); |
| impl IoDiv4MeasCtrlShadowedWriteVal { |
| #[doc = "Max threshold for io_div4 measurement"] |
| #[inline(always)] |
| pub const fn hi(self, val: u32) -> Self { |
| Self((self.0 & !(0xff << 0)) | ((val & 0xff) << 0)) |
| } |
| #[doc = "Min threshold for io_div4 measurement"] |
| #[inline(always)] |
| pub const fn lo(self, val: u32) -> Self { |
| Self((self.0 & !(0xff << 8)) | ((val & 0xff) << 8)) |
| } |
| } |
| impl From<u32> for IoDiv4MeasCtrlShadowedWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoDiv4MeasCtrlShadowedWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoDiv4MeasCtrlShadowedWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoMeasCtrlEnReadVal(pub u32); |
| impl IoMeasCtrlEnReadVal { |
| #[doc = "Enable measurement for io"] |
| #[inline(always)] |
| pub const fn en(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoMeasCtrlEnWriteVal { |
| IoMeasCtrlEnWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoMeasCtrlEnReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoMeasCtrlEnReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoMeasCtrlEnReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoMeasCtrlEnWriteVal(pub u32); |
| impl IoMeasCtrlEnWriteVal { |
| #[doc = "Enable measurement for io"] |
| #[inline(always)] |
| pub const fn en(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for IoMeasCtrlEnWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoMeasCtrlEnWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoMeasCtrlEnWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoMeasCtrlShadowedReadVal(pub u32); |
| impl IoMeasCtrlShadowedReadVal { |
| #[doc = "Max threshold for io measurement"] |
| #[inline(always)] |
| pub const fn hi(&self) -> u32 { |
| (self.0 >> 0) & 0x3ff |
| } |
| #[doc = "Min threshold for io measurement"] |
| #[inline(always)] |
| pub const fn lo(&self) -> u32 { |
| (self.0 >> 10) & 0x3ff |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> IoMeasCtrlShadowedWriteVal { |
| IoMeasCtrlShadowedWriteVal(self.0) |
| } |
| } |
| impl From<u32> for IoMeasCtrlShadowedReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoMeasCtrlShadowedReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoMeasCtrlShadowedReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct IoMeasCtrlShadowedWriteVal(pub u32); |
| impl IoMeasCtrlShadowedWriteVal { |
| #[doc = "Max threshold for io measurement"] |
| #[inline(always)] |
| pub const fn hi(self, val: u32) -> Self { |
| Self((self.0 & !(0x3ff << 0)) | ((val & 0x3ff) << 0)) |
| } |
| #[doc = "Min threshold for io measurement"] |
| #[inline(always)] |
| pub const fn lo(self, val: u32) -> Self { |
| Self((self.0 & !(0x3ff << 10)) | ((val & 0x3ff) << 10)) |
| } |
| } |
| impl From<u32> for IoMeasCtrlShadowedWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<IoMeasCtrlShadowedWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: IoMeasCtrlShadowedWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct JitterEnableReadVal(pub u32); |
| impl JitterEnableReadVal { |
| #[doc = "Enable jittery clock.\nAt reset, this register reads as kMultiBitBool4False and the jittery clock is disabled.\nAny write to the register turns the value to kMultiBitBool4True and enables the jittery clock.\nThe value written doesn't matter.\nThe value then remains kMultiBitBool4True until reset."] |
| #[inline(always)] |
| pub const fn val(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> JitterEnableWriteVal { |
| JitterEnableWriteVal(self.0) |
| } |
| } |
| impl From<u32> for JitterEnableReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<JitterEnableReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: JitterEnableReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct JitterEnableWriteVal(pub u32); |
| impl JitterEnableWriteVal { |
| #[doc = "Enable jittery clock.\nAt reset, this register reads as kMultiBitBool4False and the jittery clock is disabled.\nAny write to the register turns the value to kMultiBitBool4True and enables the jittery clock.\nThe value written doesn't matter.\nThe value then remains kMultiBitBool4True until reset."] |
| #[inline(always)] |
| pub const fn val(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for JitterEnableWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<JitterEnableWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: JitterEnableWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct JitterRegwenReadVal(pub u32); |
| impl JitterRegwenReadVal { |
| #[doc = "This register has no effect."] |
| #[inline(always)] |
| pub const fn en(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> JitterRegwenWriteVal { |
| JitterRegwenWriteVal(self.0) |
| } |
| } |
| impl From<u32> for JitterRegwenReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<JitterRegwenReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: JitterRegwenReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct JitterRegwenWriteVal(pub u32); |
| impl JitterRegwenWriteVal { |
| #[doc = "This register has no effect."] |
| #[inline(always)] |
| pub const fn en_clear(self) -> Self { |
| Self(self.0 & !(1 << 0)) |
| } |
| } |
| impl From<u32> for JitterRegwenWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<JitterRegwenWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: JitterRegwenWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MainMeasCtrlEnReadVal(pub u32); |
| impl MainMeasCtrlEnReadVal { |
| #[doc = "Enable measurement for main"] |
| #[inline(always)] |
| pub const fn en(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> MainMeasCtrlEnWriteVal { |
| MainMeasCtrlEnWriteVal(self.0) |
| } |
| } |
| impl From<u32> for MainMeasCtrlEnReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MainMeasCtrlEnReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: MainMeasCtrlEnReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MainMeasCtrlEnWriteVal(pub u32); |
| impl MainMeasCtrlEnWriteVal { |
| #[doc = "Enable measurement for main"] |
| #[inline(always)] |
| pub const fn en(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for MainMeasCtrlEnWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MainMeasCtrlEnWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: MainMeasCtrlEnWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MainMeasCtrlShadowedReadVal(pub u32); |
| impl MainMeasCtrlShadowedReadVal { |
| #[doc = "Max threshold for main measurement"] |
| #[inline(always)] |
| pub const fn hi(&self) -> u32 { |
| (self.0 >> 0) & 0x3ff |
| } |
| #[doc = "Min threshold for main measurement"] |
| #[inline(always)] |
| pub const fn lo(&self) -> u32 { |
| (self.0 >> 10) & 0x3ff |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> MainMeasCtrlShadowedWriteVal { |
| MainMeasCtrlShadowedWriteVal(self.0) |
| } |
| } |
| impl From<u32> for MainMeasCtrlShadowedReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MainMeasCtrlShadowedReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: MainMeasCtrlShadowedReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MainMeasCtrlShadowedWriteVal(pub u32); |
| impl MainMeasCtrlShadowedWriteVal { |
| #[doc = "Max threshold for main measurement"] |
| #[inline(always)] |
| pub const fn hi(self, val: u32) -> Self { |
| Self((self.0 & !(0x3ff << 0)) | ((val & 0x3ff) << 0)) |
| } |
| #[doc = "Min threshold for main measurement"] |
| #[inline(always)] |
| pub const fn lo(self, val: u32) -> Self { |
| Self((self.0 & !(0x3ff << 10)) | ((val & 0x3ff) << 10)) |
| } |
| } |
| impl From<u32> for MainMeasCtrlShadowedWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MainMeasCtrlShadowedWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: MainMeasCtrlShadowedWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MeasureCtrlRegwenReadVal(pub u32); |
| impl MeasureCtrlRegwenReadVal { |
| #[doc = "When 1, the value of the measurement control can be set. When 0, writes have no\neffect."] |
| #[inline(always)] |
| pub const fn en(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> MeasureCtrlRegwenWriteVal { |
| MeasureCtrlRegwenWriteVal(self.0) |
| } |
| } |
| impl From<u32> for MeasureCtrlRegwenReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MeasureCtrlRegwenReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: MeasureCtrlRegwenReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct MeasureCtrlRegwenWriteVal(pub u32); |
| impl MeasureCtrlRegwenWriteVal { |
| #[doc = "When 1, the value of the measurement control can be set. When 0, writes have no\neffect."] |
| #[inline(always)] |
| pub const fn en_clear(self) -> Self { |
| Self(self.0 & !(1 << 0)) |
| } |
| } |
| impl From<u32> for MeasureCtrlRegwenWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<MeasureCtrlRegwenWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: MeasureCtrlRegwenWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct RecovErrCodeReadVal(pub u32); |
| impl RecovErrCodeReadVal { |
| #[doc = "One of the shadow registers encountered an update error."] |
| #[inline(always)] |
| pub const fn shadow_update_err(&self) -> bool { |
| ((self.0 >> 0) & 1) != 0 |
| } |
| #[doc = "io has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_measure_err(&self) -> bool { |
| ((self.0 >> 1) & 1) != 0 |
| } |
| #[doc = "io_div2 has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_div2_measure_err(&self) -> bool { |
| ((self.0 >> 2) & 1) != 0 |
| } |
| #[doc = "io_div4 has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_div4_measure_err(&self) -> bool { |
| ((self.0 >> 3) & 1) != 0 |
| } |
| #[doc = "main has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn main_measure_err(&self) -> bool { |
| ((self.0 >> 4) & 1) != 0 |
| } |
| #[doc = "usb has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn usb_measure_err(&self) -> bool { |
| ((self.0 >> 5) & 1) != 0 |
| } |
| #[doc = "io has timed out."] |
| #[inline(always)] |
| pub const fn io_timeout_err(&self) -> bool { |
| ((self.0 >> 6) & 1) != 0 |
| } |
| #[doc = "io_div2 has timed out."] |
| #[inline(always)] |
| pub const fn io_div2_timeout_err(&self) -> bool { |
| ((self.0 >> 7) & 1) != 0 |
| } |
| #[doc = "io_div4 has timed out."] |
| #[inline(always)] |
| pub const fn io_div4_timeout_err(&self) -> bool { |
| ((self.0 >> 8) & 1) != 0 |
| } |
| #[doc = "main has timed out."] |
| #[inline(always)] |
| pub const fn main_timeout_err(&self) -> bool { |
| ((self.0 >> 9) & 1) != 0 |
| } |
| #[doc = "usb has timed out."] |
| #[inline(always)] |
| pub const fn usb_timeout_err(&self) -> bool { |
| ((self.0 >> 10) & 1) != 0 |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> RecovErrCodeWriteVal { |
| RecovErrCodeWriteVal(self.0) |
| } |
| } |
| impl From<u32> for RecovErrCodeReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<RecovErrCodeReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: RecovErrCodeReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct RecovErrCodeWriteVal(pub u32); |
| impl RecovErrCodeWriteVal { |
| #[doc = "One of the shadow registers encountered an update error."] |
| #[inline(always)] |
| pub const fn shadow_update_err_clear(self) -> Self { |
| Self(self.0 | (1 << 0)) |
| } |
| #[doc = "io has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_measure_err_clear(self) -> Self { |
| Self(self.0 | (1 << 1)) |
| } |
| #[doc = "io_div2 has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_div2_measure_err_clear(self) -> Self { |
| Self(self.0 | (1 << 2)) |
| } |
| #[doc = "io_div4 has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn io_div4_measure_err_clear(self) -> Self { |
| Self(self.0 | (1 << 3)) |
| } |
| #[doc = "main has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn main_measure_err_clear(self) -> Self { |
| Self(self.0 | (1 << 4)) |
| } |
| #[doc = "usb has encountered a measurement error."] |
| #[inline(always)] |
| pub const fn usb_measure_err_clear(self) -> Self { |
| Self(self.0 | (1 << 5)) |
| } |
| #[doc = "io has timed out."] |
| #[inline(always)] |
| pub const fn io_timeout_err_clear(self) -> Self { |
| Self(self.0 | (1 << 6)) |
| } |
| #[doc = "io_div2 has timed out."] |
| #[inline(always)] |
| pub const fn io_div2_timeout_err_clear(self) -> Self { |
| Self(self.0 | (1 << 7)) |
| } |
| #[doc = "io_div4 has timed out."] |
| #[inline(always)] |
| pub const fn io_div4_timeout_err_clear(self) -> Self { |
| Self(self.0 | (1 << 8)) |
| } |
| #[doc = "main has timed out."] |
| #[inline(always)] |
| pub const fn main_timeout_err_clear(self) -> Self { |
| Self(self.0 | (1 << 9)) |
| } |
| #[doc = "usb has timed out."] |
| #[inline(always)] |
| pub const fn usb_timeout_err_clear(self) -> Self { |
| Self(self.0 | (1 << 10)) |
| } |
| } |
| impl From<u32> for RecovErrCodeWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<RecovErrCodeWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: RecovErrCodeWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct UsbMeasCtrlEnReadVal(pub u32); |
| impl UsbMeasCtrlEnReadVal { |
| #[doc = "Enable measurement for usb"] |
| #[inline(always)] |
| pub const fn en(&self) -> u32 { |
| (self.0 >> 0) & 0xf |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> UsbMeasCtrlEnWriteVal { |
| UsbMeasCtrlEnWriteVal(self.0) |
| } |
| } |
| impl From<u32> for UsbMeasCtrlEnReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<UsbMeasCtrlEnReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: UsbMeasCtrlEnReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct UsbMeasCtrlEnWriteVal(pub u32); |
| impl UsbMeasCtrlEnWriteVal { |
| #[doc = "Enable measurement for usb"] |
| #[inline(always)] |
| pub const fn en(self, val: u32) -> Self { |
| Self((self.0 & !(0xf << 0)) | ((val & 0xf) << 0)) |
| } |
| } |
| impl From<u32> for UsbMeasCtrlEnWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<UsbMeasCtrlEnWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: UsbMeasCtrlEnWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct UsbMeasCtrlShadowedReadVal(pub u32); |
| impl UsbMeasCtrlShadowedReadVal { |
| #[doc = "Max threshold for usb measurement"] |
| #[inline(always)] |
| pub const fn hi(&self) -> u32 { |
| (self.0 >> 0) & 0x1ff |
| } |
| #[doc = "Min threshold for usb measurement"] |
| #[inline(always)] |
| pub const fn lo(&self) -> u32 { |
| (self.0 >> 9) & 0x1ff |
| } |
| #[doc = r" Construct a WriteVal that can be used to modify the contents of this register value."] |
| #[inline(always)] |
| pub fn modify(self) -> UsbMeasCtrlShadowedWriteVal { |
| UsbMeasCtrlShadowedWriteVal(self.0) |
| } |
| } |
| impl From<u32> for UsbMeasCtrlShadowedReadVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<UsbMeasCtrlShadowedReadVal> for u32 { |
| #[inline(always)] |
| fn from(val: UsbMeasCtrlShadowedReadVal) -> u32 { |
| val.0 |
| } |
| } |
| #[derive(Clone, Copy)] |
| pub struct UsbMeasCtrlShadowedWriteVal(pub u32); |
| impl UsbMeasCtrlShadowedWriteVal { |
| #[doc = "Max threshold for usb measurement"] |
| #[inline(always)] |
| pub const fn hi(self, val: u32) -> Self { |
| Self((self.0 & !(0x1ff << 0)) | ((val & 0x1ff) << 0)) |
| } |
| #[doc = "Min threshold for usb measurement"] |
| #[inline(always)] |
| pub const fn lo(self, val: u32) -> Self { |
| Self((self.0 & !(0x1ff << 9)) | ((val & 0x1ff) << 9)) |
| } |
| } |
| impl From<u32> for UsbMeasCtrlShadowedWriteVal { |
| #[inline(always)] |
| fn from(val: u32) -> Self { |
| Self(val) |
| } |
| } |
| impl From<UsbMeasCtrlShadowedWriteVal> for u32 { |
| #[inline(always)] |
| fn from(val: UsbMeasCtrlShadowedWriteVal) -> u32 { |
| val.0 |
| } |
| } |
| } |
| pub mod enums { |
| #![doc = r" Enumerations used by some register fields."] |
| pub mod selector {} |
| } |
| pub mod meta { |
| #![doc = r" Additional metadata needed by ureg."] |
| pub type AlertTest = ureg::WriteOnlyReg32<0, crate::regs::AlertTestWriteVal>; |
| pub type ExtclkCtrlRegwen = ureg::ReadWriteReg32< |
| 1, |
| crate::regs::ExtclkCtrlRegwenReadVal, |
| crate::regs::ExtclkCtrlRegwenWriteVal, |
| >; |
| pub type ExtclkCtrl = |
| ureg::ReadWriteReg32<0x99, crate::regs::ExtclkCtrlReadVal, crate::regs::ExtclkCtrlWriteVal>; |
| pub type ExtclkStatus = ureg::ReadOnlyReg32<crate::regs::ExtclkStatusReadVal>; |
| pub type JitterRegwen = ureg::ReadWriteReg32< |
| 1, |
| crate::regs::JitterRegwenReadVal, |
| crate::regs::JitterRegwenWriteVal, |
| >; |
| pub type JitterEnable = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::JitterEnableReadVal, |
| crate::regs::JitterEnableWriteVal, |
| >; |
| pub type ClkEnables = |
| ureg::ReadWriteReg32<0xf, crate::regs::ClkEnablesReadVal, crate::regs::ClkEnablesWriteVal>; |
| pub type ClkHints = |
| ureg::ReadWriteReg32<0xf, crate::regs::ClkHintsReadVal, crate::regs::ClkHintsWriteVal>; |
| pub type ClkHintsStatus = ureg::ReadOnlyReg32<crate::regs::ClkHintsStatusReadVal>; |
| pub type MeasureCtrlRegwen = ureg::ReadWriteReg32< |
| 1, |
| crate::regs::MeasureCtrlRegwenReadVal, |
| crate::regs::MeasureCtrlRegwenWriteVal, |
| >; |
| pub type IoMeasCtrlEn = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::IoMeasCtrlEnReadVal, |
| crate::regs::IoMeasCtrlEnWriteVal, |
| >; |
| pub type IoMeasCtrlShadowed = ureg::ReadWriteReg32< |
| 0x759ea, |
| crate::regs::IoMeasCtrlShadowedReadVal, |
| crate::regs::IoMeasCtrlShadowedWriteVal, |
| >; |
| pub type IoDiv2MeasCtrlEn = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::IoDiv2MeasCtrlEnReadVal, |
| crate::regs::IoDiv2MeasCtrlEnWriteVal, |
| >; |
| pub type IoDiv2MeasCtrlShadowed = ureg::ReadWriteReg32< |
| 0x1ccfa, |
| crate::regs::IoDiv2MeasCtrlShadowedReadVal, |
| crate::regs::IoDiv2MeasCtrlShadowedWriteVal, |
| >; |
| pub type IoDiv4MeasCtrlEn = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::IoDiv4MeasCtrlEnReadVal, |
| crate::regs::IoDiv4MeasCtrlEnWriteVal, |
| >; |
| pub type IoDiv4MeasCtrlShadowed = ureg::ReadWriteReg32< |
| 0x6e82, |
| crate::regs::IoDiv4MeasCtrlShadowedReadVal, |
| crate::regs::IoDiv4MeasCtrlShadowedWriteVal, |
| >; |
| pub type MainMeasCtrlEn = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::MainMeasCtrlEnReadVal, |
| crate::regs::MainMeasCtrlEnWriteVal, |
| >; |
| pub type MainMeasCtrlShadowed = ureg::ReadWriteReg32< |
| 0x7a9fe, |
| crate::regs::MainMeasCtrlShadowedReadVal, |
| crate::regs::MainMeasCtrlShadowedWriteVal, |
| >; |
| pub type UsbMeasCtrlEn = ureg::ReadWriteReg32< |
| 9, |
| crate::regs::UsbMeasCtrlEnReadVal, |
| crate::regs::UsbMeasCtrlEnWriteVal, |
| >; |
| pub type UsbMeasCtrlShadowed = ureg::ReadWriteReg32< |
| 0x1ccfa, |
| crate::regs::UsbMeasCtrlShadowedReadVal, |
| crate::regs::UsbMeasCtrlShadowedWriteVal, |
| >; |
| pub type RecovErrCode = ureg::ReadWriteReg32< |
| 0, |
| crate::regs::RecovErrCodeReadVal, |
| crate::regs::RecovErrCodeWriteVal, |
| >; |
| pub type FatalErrCode = ureg::ReadOnlyReg32<crate::regs::FatalErrCodeReadVal>; |
| } |
