#[doc = "EEFC Flash Command Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fcr(pub u32);
impl Fcr {
#[doc = "Flash Command"]
#[must_use]
#[inline(always)]
pub const fn fcmd(&self) -> super::vals::Fcmd {
let val = (self.0 >> 0usize) & 0xff;
super::vals::Fcmd::from_bits(val as u8)
}
#[doc = "Flash Command"]
#[inline(always)]
pub const fn set_fcmd(&mut self, val: super::vals::Fcmd) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val.to_bits() as u32) & 0xff) << 0usize);
}
#[doc = "Flash Command Argument"]
#[must_use]
#[inline(always)]
pub const fn farg(&self) -> u16 {
let val = (self.0 >> 8usize) & 0xffff;
val as u16
}
#[doc = "Flash Command Argument"]
#[inline(always)]
pub const fn set_farg(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 8usize)) | (((val as u32) & 0xffff) << 8usize);
}
#[doc = "Flash Writing Protection Key"]
#[must_use]
#[inline(always)]
pub const fn fkey(&self) -> super::vals::Fkey {
let val = (self.0 >> 24usize) & 0xff;
super::vals::Fkey::from_bits(val as u8)
}
#[doc = "Flash Writing Protection Key"]
#[inline(always)]
pub const fn set_fkey(&mut self, val: super::vals::Fkey) {
self.0 = (self.0 & !(0xff << 24usize)) | (((val.to_bits() as u32) & 0xff) << 24usize);
}
}
impl Default for Fcr {
#[inline(always)]
fn default() -> Fcr {
Fcr(0)
}
}
impl core::fmt::Debug for Fcr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fcr")
.field("fcmd", &self.fcmd())
.field("farg", &self.farg())
.field("fkey", &self.fkey())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fcr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Fcr {{ fcmd: {:?}, farg: {=u16:?}, fkey: {:?} }}",
self.fcmd(),
self.farg(),
self.fkey()
)
}
}
#[doc = "EEFC Flash Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fmr(pub u32);
impl Fmr {
#[doc = "Ready Interrupt Enable"]
#[must_use]
#[inline(always)]
pub const fn frdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Ready Interrupt Enable"]
#[inline(always)]
pub const fn set_frdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Flash Wait State"]
#[must_use]
#[inline(always)]
pub const fn fws(&self) -> u8 {
let val = (self.0 >> 8usize) & 0x0f;
val as u8
}
#[doc = "Flash Wait State"]
#[inline(always)]
pub const fn set_fws(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 8usize)) | (((val as u32) & 0x0f) << 8usize);
}
#[doc = "Sequential Code Optimization Disable"]
#[must_use]
#[inline(always)]
pub const fn scod(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Sequential Code Optimization Disable"]
#[inline(always)]
pub const fn set_scod(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Flash Access Mode"]
#[must_use]
#[inline(always)]
pub const fn fam(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Flash Access Mode"]
#[inline(always)]
pub const fn set_fam(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
}
impl Default for Fmr {
#[inline(always)]
fn default() -> Fmr {
Fmr(0)
}
}
impl core::fmt::Debug for Fmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fmr")
.field("frdy", &self.frdy())
.field("fws", &self.fws())
.field("scod", &self.scod())
.field("fam", &self.fam())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Fmr {{ frdy: {=bool:?}, fws: {=u8:?}, scod: {=bool:?}, fam: {=bool:?} }}",
self.frdy(),
self.fws(),
self.scod(),
self.fam()
)
}
}
#[doc = "EEFC Flash Result Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Frr(pub u32);
impl Frr {
#[doc = "Flash Result Value"]
#[must_use]
#[inline(always)]
pub const fn fvalue(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Flash Result Value"]
#[inline(always)]
pub const fn set_fvalue(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Frr {
#[inline(always)]
fn default() -> Frr {
Frr(0)
}
}
impl core::fmt::Debug for Frr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Frr")
.field("fvalue", &self.fvalue())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Frr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Frr {{ fvalue: {=u32:?} }}", self.fvalue())
}
}
#[doc = "EEFC Flash Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fsr(pub u32);
impl Fsr {
#[doc = "Flash Ready Status"]
#[must_use]
#[inline(always)]
pub const fn frdy(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Flash Ready Status"]
#[inline(always)]
pub const fn set_frdy(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Flash Command Error Status"]
#[must_use]
#[inline(always)]
pub const fn fcmde(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Flash Command Error Status"]
#[inline(always)]
pub const fn set_fcmde(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Flash Lock Error Status"]
#[must_use]
#[inline(always)]
pub const fn flocke(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Flash Lock Error Status"]
#[inline(always)]
pub const fn set_flocke(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Fsr {
#[inline(always)]
fn default() -> Fsr {
Fsr(0)
}
}
impl core::fmt::Debug for Fsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fsr")
.field("frdy", &self.frdy())
.field("fcmde", &self.fcmde())
.field("flocke", &self.flocke())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Fsr {{ frdy: {=bool:?}, fcmde: {=bool:?}, flocke: {=bool:?} }}",
self.frdy(),
self.fcmde(),
self.flocke()
)
}
}