#[doc = "Reader of register ECR"]
pub type R = crate::R<u32, super::ECR>;
#[doc = "Writer for register ECR"]
pub type W = crate::W<u32, super::ECR>;
#[doc = "Register ECR `reset()`'s with value 0x7000_0000"]
impl crate::ResetValue for super::ECR {
    type Type = u32;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0x7000_0000
    }
}
#[doc = "Reader of field `RESET`"]
pub type RESET_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RESET`"]
pub struct RESET_W<'a> {
    w: &'a mut W,
}
impl<'a> RESET_W<'a> {
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
        self.w
    }
}
#[doc = "Ethernet Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ETHEREN_A {
    #[doc = "0: Reception immediately stops and transmission stops after a bad CRC is appended to any currently transmitted frame."]
    ETHEREN_0 = 0,
    #[doc = "1: MAC is enabled, and reception and transmission are possible."]
    ETHEREN_1 = 1,
}
impl From<ETHEREN_A> for bool {
    #[inline(always)]
    fn from(variant: ETHEREN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `ETHEREN`"]
pub type ETHEREN_R = crate::R<bool, ETHEREN_A>;
impl ETHEREN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> ETHEREN_A {
        match self.bits {
            false => ETHEREN_A::ETHEREN_0,
            true => ETHEREN_A::ETHEREN_1,
        }
    }
    #[doc = "Checks if the value of the field is `ETHEREN_0`"]
    #[inline(always)]
    pub fn is_etheren_0(&self) -> bool {
        *self == ETHEREN_A::ETHEREN_0
    }
    #[doc = "Checks if the value of the field is `ETHEREN_1`"]
    #[inline(always)]
    pub fn is_etheren_1(&self) -> bool {
        *self == ETHEREN_A::ETHEREN_1
    }
}
#[doc = "Write proxy for field `ETHEREN`"]
pub struct ETHEREN_W<'a> {
    w: &'a mut W,
}
impl<'a> ETHEREN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: ETHEREN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Reception immediately stops and transmission stops after a bad CRC is appended to any currently transmitted frame."]
    #[inline(always)]
    pub fn etheren_0(self) -> &'a mut W {
        self.variant(ETHEREN_A::ETHEREN_0)
    }
    #[doc = "MAC is enabled, and reception and transmission are possible."]
    #[inline(always)]
    pub fn etheren_1(self) -> &'a mut W {
        self.variant(ETHEREN_A::ETHEREN_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
        self.w
    }
}
#[doc = "Magic Packet Detection Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MAGICEN_A {
    #[doc = "0: Magic detection logic disabled."]
    MAGICEN_0 = 0,
    #[doc = "1: The MAC core detects magic packets and asserts EIR\\[WAKEUP\\]
when a frame is detected."]
    MAGICEN_1 = 1,
}
impl From<MAGICEN_A> for bool {
    #[inline(always)]
    fn from(variant: MAGICEN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `MAGICEN`"]
pub type MAGICEN_R = crate::R<bool, MAGICEN_A>;
impl MAGICEN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> MAGICEN_A {
        match self.bits {
            false => MAGICEN_A::MAGICEN_0,
            true => MAGICEN_A::MAGICEN_1,
        }
    }
    #[doc = "Checks if the value of the field is `MAGICEN_0`"]
    #[inline(always)]
    pub fn is_magicen_0(&self) -> bool {
        *self == MAGICEN_A::MAGICEN_0
    }
    #[doc = "Checks if the value of the field is `MAGICEN_1`"]
    #[inline(always)]
    pub fn is_magicen_1(&self) -> bool {
        *self == MAGICEN_A::MAGICEN_1
    }
}
#[doc = "Write proxy for field `MAGICEN`"]
pub struct MAGICEN_W<'a> {
    w: &'a mut W,
}
impl<'a> MAGICEN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: MAGICEN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Magic detection logic disabled."]
    #[inline(always)]
    pub fn magicen_0(self) -> &'a mut W {
        self.variant(MAGICEN_A::MAGICEN_0)
    }
    #[doc = "The MAC core detects magic packets and asserts EIR\\[WAKEUP\\]
when a frame is detected."]
    #[inline(always)]
    pub fn magicen_1(self) -> &'a mut W {
        self.variant(MAGICEN_A::MAGICEN_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
        self.w
    }
}
#[doc = "Sleep Mode Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SLEEP_A {
    #[doc = "0: Normal operating mode."]
    SLEEP_0 = 0,
    #[doc = "1: Sleep mode."]
    SLEEP_1 = 1,
}
impl From<SLEEP_A> for bool {
    #[inline(always)]
    fn from(variant: SLEEP_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `SLEEP`"]
pub type SLEEP_R = crate::R<bool, SLEEP_A>;
impl SLEEP_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> SLEEP_A {
        match self.bits {
            false => SLEEP_A::SLEEP_0,
            true => SLEEP_A::SLEEP_1,
        }
    }
    #[doc = "Checks if the value of the field is `SLEEP_0`"]
    #[inline(always)]
    pub fn is_sleep_0(&self) -> bool {
        *self == SLEEP_A::SLEEP_0
    }
    #[doc = "Checks if the value of the field is `SLEEP_1`"]
    #[inline(always)]
    pub fn is_sleep_1(&self) -> bool {
        *self == SLEEP_A::SLEEP_1
    }
}
#[doc = "Write proxy for field `SLEEP`"]
pub struct SLEEP_W<'a> {
    w: &'a mut W,
}
impl<'a> SLEEP_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: SLEEP_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Normal operating mode."]
    #[inline(always)]
    pub fn sleep_0(self) -> &'a mut W {
        self.variant(SLEEP_A::SLEEP_0)
    }
    #[doc = "Sleep mode."]
    #[inline(always)]
    pub fn sleep_1(self) -> &'a mut W {
        self.variant(SLEEP_A::SLEEP_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
        self.w
    }
}
#[doc = "EN1588 Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EN1588_A {
    #[doc = "0: Legacy FEC buffer descriptors and functions enabled."]
    EN1588_0 = 0,
    #[doc = "1: Enhanced frame time-stamping functions enabled."]
    EN1588_1 = 1,
}
impl From<EN1588_A> for bool {
    #[inline(always)]
    fn from(variant: EN1588_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `EN1588`"]
pub type EN1588_R = crate::R<bool, EN1588_A>;
impl EN1588_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> EN1588_A {
        match self.bits {
            false => EN1588_A::EN1588_0,
            true => EN1588_A::EN1588_1,
        }
    }
    #[doc = "Checks if the value of the field is `EN1588_0`"]
    #[inline(always)]
    pub fn is_en1588_0(&self) -> bool {
        *self == EN1588_A::EN1588_0
    }
    #[doc = "Checks if the value of the field is `EN1588_1`"]
    #[inline(always)]
    pub fn is_en1588_1(&self) -> bool {
        *self == EN1588_A::EN1588_1
    }
}
#[doc = "Write proxy for field `EN1588`"]
pub struct EN1588_W<'a> {
    w: &'a mut W,
}
impl<'a> EN1588_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: EN1588_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Legacy FEC buffer descriptors and functions enabled."]
    #[inline(always)]
    pub fn en1588_0(self) -> &'a mut W {
        self.variant(EN1588_A::EN1588_0)
    }
    #[doc = "Enhanced frame time-stamping functions enabled."]
    #[inline(always)]
    pub fn en1588_1(self) -> &'a mut W {
        self.variant(EN1588_A::EN1588_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
        self.w
    }
}
#[doc = "Debug Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DBGEN_A {
    #[doc = "0: MAC continues operation in debug mode."]
    DBGEN_0 = 0,
    #[doc = "1: MAC enters hardware freeze mode when the processor is in debug mode."]
    DBGEN_1 = 1,
}
impl From<DBGEN_A> for bool {
    #[inline(always)]
    fn from(variant: DBGEN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `DBGEN`"]
pub type DBGEN_R = crate::R<bool, DBGEN_A>;
impl DBGEN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> DBGEN_A {
        match self.bits {
            false => DBGEN_A::DBGEN_0,
            true => DBGEN_A::DBGEN_1,
        }
    }
    #[doc = "Checks if the value of the field is `DBGEN_0`"]
    #[inline(always)]
    pub fn is_dbgen_0(&self) -> bool {
        *self == DBGEN_A::DBGEN_0
    }
    #[doc = "Checks if the value of the field is `DBGEN_1`"]
    #[inline(always)]
    pub fn is_dbgen_1(&self) -> bool {
        *self == DBGEN_A::DBGEN_1
    }
}
#[doc = "Write proxy for field `DBGEN`"]
pub struct DBGEN_W<'a> {
    w: &'a mut W,
}
impl<'a> DBGEN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: DBGEN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "MAC continues operation in debug mode."]
    #[inline(always)]
    pub fn dbgen_0(self) -> &'a mut W {
        self.variant(DBGEN_A::DBGEN_0)
    }
    #[doc = "MAC enters hardware freeze mode when the processor is in debug mode."]
    #[inline(always)]
    pub fn dbgen_1(self) -> &'a mut W {
        self.variant(DBGEN_A::DBGEN_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
        self.w
    }
}
#[doc = "Descriptor Byte Swapping Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DBSWP_A {
    #[doc = "0: The buffer descriptor bytes are not swapped to support big-endian devices."]
    DBSWP_0 = 0,
    #[doc = "1: The buffer descriptor bytes are swapped to support little-endian devices."]
    DBSWP_1 = 1,
}
impl From<DBSWP_A> for bool {
    #[inline(always)]
    fn from(variant: DBSWP_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `DBSWP`"]
pub type DBSWP_R = crate::R<bool, DBSWP_A>;
impl DBSWP_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> DBSWP_A {
        match self.bits {
            false => DBSWP_A::DBSWP_0,
            true => DBSWP_A::DBSWP_1,
        }
    }
    #[doc = "Checks if the value of the field is `DBSWP_0`"]
    #[inline(always)]
    pub fn is_dbswp_0(&self) -> bool {
        *self == DBSWP_A::DBSWP_0
    }
    #[doc = "Checks if the value of the field is `DBSWP_1`"]
    #[inline(always)]
    pub fn is_dbswp_1(&self) -> bool {
        *self == DBSWP_A::DBSWP_1
    }
}
#[doc = "Write proxy for field `DBSWP`"]
pub struct DBSWP_W<'a> {
    w: &'a mut W,
}
impl<'a> DBSWP_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: DBSWP_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "The buffer descriptor bytes are not swapped to support big-endian devices."]
    #[inline(always)]
    pub fn dbswp_0(self) -> &'a mut W {
        self.variant(DBSWP_A::DBSWP_0)
    }
    #[doc = "The buffer descriptor bytes are swapped to support little-endian devices."]
    #[inline(always)]
    pub fn dbswp_1(self) -> &'a mut W {
        self.variant(DBSWP_A::DBSWP_1)
    }
    #[doc = r"Sets the field bit"]
    #[inline(always)]
    pub fn set_bit(self) -> &'a mut W {
        self.bit(true)
    }
    #[doc = r"Clears the field bit"]
    #[inline(always)]
    pub fn clear_bit(self) -> &'a mut W {
        self.bit(false)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub fn bit(self, value: bool) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
        self.w
    }
}
impl R {
    #[doc = "Bit 0 - Ethernet MAC Reset"]
    #[inline(always)]
    pub fn reset(&self) -> RESET_R {
        RESET_R::new((self.bits & 0x01) != 0)
    }
    #[doc = "Bit 1 - Ethernet Enable"]
    #[inline(always)]
    pub fn etheren(&self) -> ETHEREN_R {
        ETHEREN_R::new(((self.bits >> 1) & 0x01) != 0)
    }
    #[doc = "Bit 2 - Magic Packet Detection Enable"]
    #[inline(always)]
    pub fn magicen(&self) -> MAGICEN_R {
        MAGICEN_R::new(((self.bits >> 2) & 0x01) != 0)
    }
    #[doc = "Bit 3 - Sleep Mode Enable"]
    #[inline(always)]
    pub fn sleep(&self) -> SLEEP_R {
        SLEEP_R::new(((self.bits >> 3) & 0x01) != 0)
    }
    #[doc = "Bit 4 - EN1588 Enable"]
    #[inline(always)]
    pub fn en1588(&self) -> EN1588_R {
        EN1588_R::new(((self.bits >> 4) & 0x01) != 0)
    }
    #[doc = "Bit 6 - Debug Enable"]
    #[inline(always)]
    pub fn dbgen(&self) -> DBGEN_R {
        DBGEN_R::new(((self.bits >> 6) & 0x01) != 0)
    }
    #[doc = "Bit 8 - Descriptor Byte Swapping Enable"]
    #[inline(always)]
    pub fn dbswp(&self) -> DBSWP_R {
        DBSWP_R::new(((self.bits >> 8) & 0x01) != 0)
    }
}
impl W {
    #[doc = "Bit 0 - Ethernet MAC Reset"]
    #[inline(always)]
    pub fn reset(&mut self) -> RESET_W {
        RESET_W { w: self }
    }
    #[doc = "Bit 1 - Ethernet Enable"]
    #[inline(always)]
    pub fn etheren(&mut self) -> ETHEREN_W {
        ETHEREN_W { w: self }
    }
    #[doc = "Bit 2 - Magic Packet Detection Enable"]
    #[inline(always)]
    pub fn magicen(&mut self) -> MAGICEN_W {
        MAGICEN_W { w: self }
    }
    #[doc = "Bit 3 - Sleep Mode Enable"]
    #[inline(always)]
    pub fn sleep(&mut self) -> SLEEP_W {
        SLEEP_W { w: self }
    }
    #[doc = "Bit 4 - EN1588 Enable"]
    #[inline(always)]
    pub fn en1588(&mut self) -> EN1588_W {
        EN1588_W { w: self }
    }
    #[doc = "Bit 6 - Debug Enable"]
    #[inline(always)]
    pub fn dbgen(&mut self) -> DBGEN_W {
        DBGEN_W { w: self }
    }
    #[doc = "Bit 8 - Descriptor Byte Swapping Enable"]
    #[inline(always)]
    pub fn dbswp(&mut self) -> DBSWP_W {
        DBSWP_W { w: self }
    }
}