#[doc = "Reader of register GPR10"]
pub type R = crate::R<u32, super::GPR10>;
#[doc = "Writer for register GPR10"]
pub type W = crate::W<u32, super::GPR10>;
#[doc = "Register GPR10 `reset()`'s with value 0x07"]
impl crate::ResetValue for super::GPR10 {
    type Type = u32;
    #[inline(always)]
    fn reset_value() -> Self::Type {
        0x07
    }
}
#[doc = "ARM non-secure (non-invasive) debug enable\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum NIDEN_A {
    #[doc = "0: Debug turned off."]
    NIDEN_0 = 0,
    #[doc = "1: Debug enabled (default)."]
    NIDEN_1 = 1,
}
impl From<NIDEN_A> for bool {
    #[inline(always)]
    fn from(variant: NIDEN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `NIDEN`"]
pub type NIDEN_R = crate::R<bool, NIDEN_A>;
impl NIDEN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> NIDEN_A {
        match self.bits {
            false => NIDEN_A::NIDEN_0,
            true => NIDEN_A::NIDEN_1,
        }
    }
    #[doc = "Checks if the value of the field is `NIDEN_0`"]
    #[inline(always)]
    pub fn is_niden_0(&self) -> bool {
        *self == NIDEN_A::NIDEN_0
    }
    #[doc = "Checks if the value of the field is `NIDEN_1`"]
    #[inline(always)]
    pub fn is_niden_1(&self) -> bool {
        *self == NIDEN_A::NIDEN_1
    }
}
#[doc = "Write proxy for field `NIDEN`"]
pub struct NIDEN_W<'a> {
    w: &'a mut W,
}
impl<'a> NIDEN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: NIDEN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Debug turned off."]
    #[inline(always)]
    pub fn niden_0(self) -> &'a mut W {
        self.variant(NIDEN_A::NIDEN_0)
    }
    #[doc = "Debug enabled (default)."]
    #[inline(always)]
    pub fn niden_1(self) -> &'a mut W {
        self.variant(NIDEN_A::NIDEN_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) | ((value as u32) & 0x01);
        self.w
    }
}
#[doc = "ARM invasive debug enable\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DBG_EN_A {
    #[doc = "0: Debug turned off."]
    DBG_EN_0 = 0,
    #[doc = "1: Debug enabled (default)."]
    DBG_EN_1 = 1,
}
impl From<DBG_EN_A> for bool {
    #[inline(always)]
    fn from(variant: DBG_EN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `DBG_EN`"]
pub type DBG_EN_R = crate::R<bool, DBG_EN_A>;
impl DBG_EN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> DBG_EN_A {
        match self.bits {
            false => DBG_EN_A::DBG_EN_0,
            true => DBG_EN_A::DBG_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `DBG_EN_0`"]
    #[inline(always)]
    pub fn is_dbg_en_0(&self) -> bool {
        *self == DBG_EN_A::DBG_EN_0
    }
    #[doc = "Checks if the value of the field is `DBG_EN_1`"]
    #[inline(always)]
    pub fn is_dbg_en_1(&self) -> bool {
        *self == DBG_EN_A::DBG_EN_1
    }
}
#[doc = "Write proxy for field `DBG_EN`"]
pub struct DBG_EN_W<'a> {
    w: &'a mut W,
}
impl<'a> DBG_EN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: DBG_EN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Debug turned off."]
    #[inline(always)]
    pub fn dbg_en_0(self) -> &'a mut W {
        self.variant(DBG_EN_A::DBG_EN_0)
    }
    #[doc = "Debug enabled (default)."]
    #[inline(always)]
    pub fn dbg_en_1(self) -> &'a mut W {
        self.variant(DBG_EN_A::DBG_EN_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 = "Security error response enable for all security gaskets (on both AHB and AXI buses)\n\nValue on reset: 1"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SEC_ERR_RESP_A {
    #[doc = "0: OKEY response"]
    SEC_ERR_RESP_0 = 0,
    #[doc = "1: SLVError (default)"]
    SEC_ERR_RESP_1 = 1,
}
impl From<SEC_ERR_RESP_A> for bool {
    #[inline(always)]
    fn from(variant: SEC_ERR_RESP_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `SEC_ERR_RESP`"]
pub type SEC_ERR_RESP_R = crate::R<bool, SEC_ERR_RESP_A>;
impl SEC_ERR_RESP_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> SEC_ERR_RESP_A {
        match self.bits {
            false => SEC_ERR_RESP_A::SEC_ERR_RESP_0,
            true => SEC_ERR_RESP_A::SEC_ERR_RESP_1,
        }
    }
    #[doc = "Checks if the value of the field is `SEC_ERR_RESP_0`"]
    #[inline(always)]
    pub fn is_sec_err_resp_0(&self) -> bool {
        *self == SEC_ERR_RESP_A::SEC_ERR_RESP_0
    }
    #[doc = "Checks if the value of the field is `SEC_ERR_RESP_1`"]
    #[inline(always)]
    pub fn is_sec_err_resp_1(&self) -> bool {
        *self == SEC_ERR_RESP_A::SEC_ERR_RESP_1
    }
}
#[doc = "Write proxy for field `SEC_ERR_RESP`"]
pub struct SEC_ERR_RESP_W<'a> {
    w: &'a mut W,
}
impl<'a> SEC_ERR_RESP_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: SEC_ERR_RESP_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "OKEY response"]
    #[inline(always)]
    pub fn sec_err_resp_0(self) -> &'a mut W {
        self.variant(SEC_ERR_RESP_A::SEC_ERR_RESP_0)
    }
    #[doc = "SLVError (default)"]
    #[inline(always)]
    pub fn sec_err_resp_1(self) -> &'a mut W {
        self.variant(SEC_ERR_RESP_A::SEC_ERR_RESP_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 = "DCP Key selection bit.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DCPKEY_OCOTP_OR_KEYMUX_A {
    #[doc = "0: Select key from Key MUX (SNVS/OTPMK)."]
    DCPKEY_OCOTP_OR_KEYMUX_0 = 0,
    #[doc = "1: Select key from OCOTP (SW_GP2)."]
    DCPKEY_OCOTP_OR_KEYMUX_1 = 1,
}
impl From<DCPKEY_OCOTP_OR_KEYMUX_A> for bool {
    #[inline(always)]
    fn from(variant: DCPKEY_OCOTP_OR_KEYMUX_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `DCPKEY_OCOTP_OR_KEYMUX`"]
pub type DCPKEY_OCOTP_OR_KEYMUX_R = crate::R<bool, DCPKEY_OCOTP_OR_KEYMUX_A>;
impl DCPKEY_OCOTP_OR_KEYMUX_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> DCPKEY_OCOTP_OR_KEYMUX_A {
        match self.bits {
            false => DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_0,
            true => DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_1,
        }
    }
    #[doc = "Checks if the value of the field is `DCPKEY_OCOTP_OR_KEYMUX_0`"]
    #[inline(always)]
    pub fn is_dcpkey_ocotp_or_keymux_0(&self) -> bool {
        *self == DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_0
    }
    #[doc = "Checks if the value of the field is `DCPKEY_OCOTP_OR_KEYMUX_1`"]
    #[inline(always)]
    pub fn is_dcpkey_ocotp_or_keymux_1(&self) -> bool {
        *self == DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_1
    }
}
#[doc = "Write proxy for field `DCPKEY_OCOTP_OR_KEYMUX`"]
pub struct DCPKEY_OCOTP_OR_KEYMUX_W<'a> {
    w: &'a mut W,
}
impl<'a> DCPKEY_OCOTP_OR_KEYMUX_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: DCPKEY_OCOTP_OR_KEYMUX_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Select key from Key MUX (SNVS/OTPMK)."]
    #[inline(always)]
    pub fn dcpkey_ocotp_or_keymux_0(self) -> &'a mut W {
        self.variant(DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_0)
    }
    #[doc = "Select key from OCOTP (SW_GP2)."]
    #[inline(always)]
    pub fn dcpkey_ocotp_or_keymux_1(self) -> &'a mut W {
        self.variant(DCPKEY_OCOTP_OR_KEYMUX_A::DCPKEY_OCOTP_OR_KEYMUX_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 = "OCRAM TrustZone (TZ) enable.\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OCRAM_TZ_EN_A {
    #[doc = "0: The TrustZone feature is disabled. Entire OCRAM space is available for all access types (secure/non-secure/user/supervisor)."]
    OCRAM_TZ_EN_0 = 0,
    #[doc = "1: The TrustZone feature is enabled. Access to address in the range specified by \\[ENDADDR:STARTADDR\\]
follows the execution mode access policy described in CSU chapter."]
    OCRAM_TZ_EN_1 = 1,
}
impl From<OCRAM_TZ_EN_A> for bool {
    #[inline(always)]
    fn from(variant: OCRAM_TZ_EN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `OCRAM_TZ_EN`"]
pub type OCRAM_TZ_EN_R = crate::R<bool, OCRAM_TZ_EN_A>;
impl OCRAM_TZ_EN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> OCRAM_TZ_EN_A {
        match self.bits {
            false => OCRAM_TZ_EN_A::OCRAM_TZ_EN_0,
            true => OCRAM_TZ_EN_A::OCRAM_TZ_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `OCRAM_TZ_EN_0`"]
    #[inline(always)]
    pub fn is_ocram_tz_en_0(&self) -> bool {
        *self == OCRAM_TZ_EN_A::OCRAM_TZ_EN_0
    }
    #[doc = "Checks if the value of the field is `OCRAM_TZ_EN_1`"]
    #[inline(always)]
    pub fn is_ocram_tz_en_1(&self) -> bool {
        *self == OCRAM_TZ_EN_A::OCRAM_TZ_EN_1
    }
}
#[doc = "Write proxy for field `OCRAM_TZ_EN`"]
pub struct OCRAM_TZ_EN_W<'a> {
    w: &'a mut W,
}
impl<'a> OCRAM_TZ_EN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: OCRAM_TZ_EN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "The TrustZone feature is disabled. Entire OCRAM space is available for all access types (secure/non-secure/user/supervisor)."]
    #[inline(always)]
    pub fn ocram_tz_en_0(self) -> &'a mut W {
        self.variant(OCRAM_TZ_EN_A::OCRAM_TZ_EN_0)
    }
    #[doc = "The TrustZone feature is enabled. Access to address in the range specified by \\[ENDADDR:STARTADDR\\]
follows the execution mode access policy described in CSU chapter."]
    #[inline(always)]
    pub fn ocram_tz_en_1(self) -> &'a mut W {
        self.variant(OCRAM_TZ_EN_A::OCRAM_TZ_EN_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
    }
}
#[doc = "Reader of field `OCRAM_TZ_ADDR`"]
pub type OCRAM_TZ_ADDR_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `OCRAM_TZ_ADDR`"]
pub struct OCRAM_TZ_ADDR_W<'a> {
    w: &'a mut W,
}
impl<'a> OCRAM_TZ_ADDR_W<'a> {
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x7f << 9)) | (((value as u32) & 0x7f) << 9);
        self.w
    }
}
#[doc = "Lock NIDEN field for changes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_NIDEN_A {
    #[doc = "0: Field is not locked"]
    LOCK_NIDEN_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_NIDEN_1 = 1,
}
impl From<LOCK_NIDEN_A> for bool {
    #[inline(always)]
    fn from(variant: LOCK_NIDEN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `LOCK_NIDEN`"]
pub type LOCK_NIDEN_R = crate::R<bool, LOCK_NIDEN_A>;
impl LOCK_NIDEN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> LOCK_NIDEN_A {
        match self.bits {
            false => LOCK_NIDEN_A::LOCK_NIDEN_0,
            true => LOCK_NIDEN_A::LOCK_NIDEN_1,
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_NIDEN_0`"]
    #[inline(always)]
    pub fn is_lock_niden_0(&self) -> bool {
        *self == LOCK_NIDEN_A::LOCK_NIDEN_0
    }
    #[doc = "Checks if the value of the field is `LOCK_NIDEN_1`"]
    #[inline(always)]
    pub fn is_lock_niden_1(&self) -> bool {
        *self == LOCK_NIDEN_A::LOCK_NIDEN_1
    }
}
#[doc = "Write proxy for field `LOCK_NIDEN`"]
pub struct LOCK_NIDEN_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_NIDEN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_NIDEN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_niden_0(self) -> &'a mut W {
        self.variant(LOCK_NIDEN_A::LOCK_NIDEN_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_niden_1(self) -> &'a mut W {
        self.variant(LOCK_NIDEN_A::LOCK_NIDEN_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 << 16)) | (((value as u32) & 0x01) << 16);
        self.w
    }
}
#[doc = "Lock DBG_EN field for changes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_DBG_EN_A {
    #[doc = "0: Field is not locked"]
    LOCK_DBG_EN_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_DBG_EN_1 = 1,
}
impl From<LOCK_DBG_EN_A> for bool {
    #[inline(always)]
    fn from(variant: LOCK_DBG_EN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `LOCK_DBG_EN`"]
pub type LOCK_DBG_EN_R = crate::R<bool, LOCK_DBG_EN_A>;
impl LOCK_DBG_EN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> LOCK_DBG_EN_A {
        match self.bits {
            false => LOCK_DBG_EN_A::LOCK_DBG_EN_0,
            true => LOCK_DBG_EN_A::LOCK_DBG_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_DBG_EN_0`"]
    #[inline(always)]
    pub fn is_lock_dbg_en_0(&self) -> bool {
        *self == LOCK_DBG_EN_A::LOCK_DBG_EN_0
    }
    #[doc = "Checks if the value of the field is `LOCK_DBG_EN_1`"]
    #[inline(always)]
    pub fn is_lock_dbg_en_1(&self) -> bool {
        *self == LOCK_DBG_EN_A::LOCK_DBG_EN_1
    }
}
#[doc = "Write proxy for field `LOCK_DBG_EN`"]
pub struct LOCK_DBG_EN_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_DBG_EN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_DBG_EN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_dbg_en_0(self) -> &'a mut W {
        self.variant(LOCK_DBG_EN_A::LOCK_DBG_EN_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_dbg_en_1(self) -> &'a mut W {
        self.variant(LOCK_DBG_EN_A::LOCK_DBG_EN_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 << 17)) | (((value as u32) & 0x01) << 17);
        self.w
    }
}
#[doc = "Lock SEC_ERR_RESP field for changes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_SEC_ERR_RESP_A {
    #[doc = "0: Field is not locked"]
    LOCK_SEC_ERR_RESP_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_SEC_ERR_RESP_1 = 1,
}
impl From<LOCK_SEC_ERR_RESP_A> for bool {
    #[inline(always)]
    fn from(variant: LOCK_SEC_ERR_RESP_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `LOCK_SEC_ERR_RESP`"]
pub type LOCK_SEC_ERR_RESP_R = crate::R<bool, LOCK_SEC_ERR_RESP_A>;
impl LOCK_SEC_ERR_RESP_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> LOCK_SEC_ERR_RESP_A {
        match self.bits {
            false => LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_0,
            true => LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_1,
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_SEC_ERR_RESP_0`"]
    #[inline(always)]
    pub fn is_lock_sec_err_resp_0(&self) -> bool {
        *self == LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_0
    }
    #[doc = "Checks if the value of the field is `LOCK_SEC_ERR_RESP_1`"]
    #[inline(always)]
    pub fn is_lock_sec_err_resp_1(&self) -> bool {
        *self == LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_1
    }
}
#[doc = "Write proxy for field `LOCK_SEC_ERR_RESP`"]
pub struct LOCK_SEC_ERR_RESP_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_SEC_ERR_RESP_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_SEC_ERR_RESP_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_sec_err_resp_0(self) -> &'a mut W {
        self.variant(LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_sec_err_resp_1(self) -> &'a mut W {
        self.variant(LOCK_SEC_ERR_RESP_A::LOCK_SEC_ERR_RESP_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 << 18)) | (((value as u32) & 0x01) << 18);
        self.w
    }
}
#[doc = "Lock DCP Key OCOTP/Key MUX selection bit\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_DCPKEY_OCOTP_OR_KEYMUX_A {
    #[doc = "0: Field is not locked"]
    LOCK_DCPKEY_OCOTP_OR_KEYMUX_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_DCPKEY_OCOTP_OR_KEYMUX_1 = 1,
}
impl From<LOCK_DCPKEY_OCOTP_OR_KEYMUX_A> for bool {
    #[inline(always)]
    fn from(variant: LOCK_DCPKEY_OCOTP_OR_KEYMUX_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `LOCK_DCPKEY_OCOTP_OR_KEYMUX`"]
pub type LOCK_DCPKEY_OCOTP_OR_KEYMUX_R = crate::R<bool, LOCK_DCPKEY_OCOTP_OR_KEYMUX_A>;
impl LOCK_DCPKEY_OCOTP_OR_KEYMUX_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> LOCK_DCPKEY_OCOTP_OR_KEYMUX_A {
        match self.bits {
            false => LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_0,
            true => LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_1,
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_DCPKEY_OCOTP_OR_KEYMUX_0`"]
    #[inline(always)]
    pub fn is_lock_dcpkey_ocotp_or_keymux_0(&self) -> bool {
        *self == LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_0
    }
    #[doc = "Checks if the value of the field is `LOCK_DCPKEY_OCOTP_OR_KEYMUX_1`"]
    #[inline(always)]
    pub fn is_lock_dcpkey_ocotp_or_keymux_1(&self) -> bool {
        *self == LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_1
    }
}
#[doc = "Write proxy for field `LOCK_DCPKEY_OCOTP_OR_KEYMUX`"]
pub struct LOCK_DCPKEY_OCOTP_OR_KEYMUX_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_DCPKEY_OCOTP_OR_KEYMUX_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_DCPKEY_OCOTP_OR_KEYMUX_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_dcpkey_ocotp_or_keymux_0(self) -> &'a mut W {
        self.variant(LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_dcpkey_ocotp_or_keymux_1(self) -> &'a mut W {
        self.variant(LOCK_DCPKEY_OCOTP_OR_KEYMUX_A::LOCK_DCPKEY_OCOTP_OR_KEYMUX_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 << 20)) | (((value as u32) & 0x01) << 20);
        self.w
    }
}
#[doc = "Lock OCRAM_TZ_EN field for changes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LOCK_OCRAM_TZ_EN_A {
    #[doc = "0: Field is not locked"]
    LOCK_OCRAM_TZ_EN_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_OCRAM_TZ_EN_1 = 1,
}
impl From<LOCK_OCRAM_TZ_EN_A> for bool {
    #[inline(always)]
    fn from(variant: LOCK_OCRAM_TZ_EN_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Reader of field `LOCK_OCRAM_TZ_EN`"]
pub type LOCK_OCRAM_TZ_EN_R = crate::R<bool, LOCK_OCRAM_TZ_EN_A>;
impl LOCK_OCRAM_TZ_EN_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> LOCK_OCRAM_TZ_EN_A {
        match self.bits {
            false => LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_0,
            true => LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_1,
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_OCRAM_TZ_EN_0`"]
    #[inline(always)]
    pub fn is_lock_ocram_tz_en_0(&self) -> bool {
        *self == LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_0
    }
    #[doc = "Checks if the value of the field is `LOCK_OCRAM_TZ_EN_1`"]
    #[inline(always)]
    pub fn is_lock_ocram_tz_en_1(&self) -> bool {
        *self == LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_1
    }
}
#[doc = "Write proxy for field `LOCK_OCRAM_TZ_EN`"]
pub struct LOCK_OCRAM_TZ_EN_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_OCRAM_TZ_EN_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_OCRAM_TZ_EN_A) -> &'a mut W {
        {
            self.bit(variant.into())
        }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_ocram_tz_en_0(self) -> &'a mut W {
        self.variant(LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_ocram_tz_en_1(self) -> &'a mut W {
        self.variant(LOCK_OCRAM_TZ_EN_A::LOCK_OCRAM_TZ_EN_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 << 24)) | (((value as u32) & 0x01) << 24);
        self.w
    }
}
#[doc = "Lock OCRAM_TZ_ADDR field for changes\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum LOCK_OCRAM_TZ_ADDR_A {
    #[doc = "0: Field is not locked"]
    LOCK_OCRAM_TZ_ADDR_0 = 0,
    #[doc = "1: Field is locked (read access only)"]
    LOCK_OCRAM_TZ_ADDR_1 = 1,
}
impl From<LOCK_OCRAM_TZ_ADDR_A> for u8 {
    #[inline(always)]
    fn from(variant: LOCK_OCRAM_TZ_ADDR_A) -> Self {
        variant as _
    }
}
#[doc = "Reader of field `LOCK_OCRAM_TZ_ADDR`"]
pub type LOCK_OCRAM_TZ_ADDR_R = crate::R<u8, LOCK_OCRAM_TZ_ADDR_A>;
impl LOCK_OCRAM_TZ_ADDR_R {
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> crate::Variant<u8, LOCK_OCRAM_TZ_ADDR_A> {
        use crate::Variant::*;
        match self.bits {
            0 => Val(LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_0),
            1 => Val(LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_1),
            i => Res(i),
        }
    }
    #[doc = "Checks if the value of the field is `LOCK_OCRAM_TZ_ADDR_0`"]
    #[inline(always)]
    pub fn is_lock_ocram_tz_addr_0(&self) -> bool {
        *self == LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_0
    }
    #[doc = "Checks if the value of the field is `LOCK_OCRAM_TZ_ADDR_1`"]
    #[inline(always)]
    pub fn is_lock_ocram_tz_addr_1(&self) -> bool {
        *self == LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_1
    }
}
#[doc = "Write proxy for field `LOCK_OCRAM_TZ_ADDR`"]
pub struct LOCK_OCRAM_TZ_ADDR_W<'a> {
    w: &'a mut W,
}
impl<'a> LOCK_OCRAM_TZ_ADDR_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: LOCK_OCRAM_TZ_ADDR_A) -> &'a mut W {
        unsafe { self.bits(variant.into()) }
    }
    #[doc = "Field is not locked"]
    #[inline(always)]
    pub fn lock_ocram_tz_addr_0(self) -> &'a mut W {
        self.variant(LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_0)
    }
    #[doc = "Field is locked (read access only)"]
    #[inline(always)]
    pub fn lock_ocram_tz_addr_1(self) -> &'a mut W {
        self.variant(LOCK_OCRAM_TZ_ADDR_A::LOCK_OCRAM_TZ_ADDR_1)
    }
    #[doc = r"Writes raw bits to the field"]
    #[inline(always)]
    pub unsafe fn bits(self, value: u8) -> &'a mut W {
        self.w.bits = (self.w.bits & !(0x7f << 25)) | (((value as u32) & 0x7f) << 25);
        self.w
    }
}
impl R {
    #[doc = "Bit 0 - ARM non-secure (non-invasive) debug enable"]
    #[inline(always)]
    pub fn niden(&self) -> NIDEN_R {
        NIDEN_R::new((self.bits & 0x01) != 0)
    }
    #[doc = "Bit 1 - ARM invasive debug enable"]
    #[inline(always)]
    pub fn dbg_en(&self) -> DBG_EN_R {
        DBG_EN_R::new(((self.bits >> 1) & 0x01) != 0)
    }
    #[doc = "Bit 2 - Security error response enable for all security gaskets (on both AHB and AXI buses)"]
    #[inline(always)]
    pub fn sec_err_resp(&self) -> SEC_ERR_RESP_R {
        SEC_ERR_RESP_R::new(((self.bits >> 2) & 0x01) != 0)
    }
    #[doc = "Bit 4 - DCP Key selection bit."]
    #[inline(always)]
    pub fn dcpkey_ocotp_or_keymux(&self) -> DCPKEY_OCOTP_OR_KEYMUX_R {
        DCPKEY_OCOTP_OR_KEYMUX_R::new(((self.bits >> 4) & 0x01) != 0)
    }
    #[doc = "Bit 8 - OCRAM TrustZone (TZ) enable."]
    #[inline(always)]
    pub fn ocram_tz_en(&self) -> OCRAM_TZ_EN_R {
        OCRAM_TZ_EN_R::new(((self.bits >> 8) & 0x01) != 0)
    }
    #[doc = "Bits 9:15 - OCRAM TrustZone (TZ) start address"]
    #[inline(always)]
    pub fn ocram_tz_addr(&self) -> OCRAM_TZ_ADDR_R {
        OCRAM_TZ_ADDR_R::new(((self.bits >> 9) & 0x7f) as u8)
    }
    #[doc = "Bit 16 - Lock NIDEN field for changes"]
    #[inline(always)]
    pub fn lock_niden(&self) -> LOCK_NIDEN_R {
        LOCK_NIDEN_R::new(((self.bits >> 16) & 0x01) != 0)
    }
    #[doc = "Bit 17 - Lock DBG_EN field for changes"]
    #[inline(always)]
    pub fn lock_dbg_en(&self) -> LOCK_DBG_EN_R {
        LOCK_DBG_EN_R::new(((self.bits >> 17) & 0x01) != 0)
    }
    #[doc = "Bit 18 - Lock SEC_ERR_RESP field for changes"]
    #[inline(always)]
    pub fn lock_sec_err_resp(&self) -> LOCK_SEC_ERR_RESP_R {
        LOCK_SEC_ERR_RESP_R::new(((self.bits >> 18) & 0x01) != 0)
    }
    #[doc = "Bit 20 - Lock DCP Key OCOTP/Key MUX selection bit"]
    #[inline(always)]
    pub fn lock_dcpkey_ocotp_or_keymux(&self) -> LOCK_DCPKEY_OCOTP_OR_KEYMUX_R {
        LOCK_DCPKEY_OCOTP_OR_KEYMUX_R::new(((self.bits >> 20) & 0x01) != 0)
    }
    #[doc = "Bit 24 - Lock OCRAM_TZ_EN field for changes"]
    #[inline(always)]
    pub fn lock_ocram_tz_en(&self) -> LOCK_OCRAM_TZ_EN_R {
        LOCK_OCRAM_TZ_EN_R::new(((self.bits >> 24) & 0x01) != 0)
    }
    #[doc = "Bits 25:31 - Lock OCRAM_TZ_ADDR field for changes"]
    #[inline(always)]
    pub fn lock_ocram_tz_addr(&self) -> LOCK_OCRAM_TZ_ADDR_R {
        LOCK_OCRAM_TZ_ADDR_R::new(((self.bits >> 25) & 0x7f) as u8)
    }
}
impl W {
    #[doc = "Bit 0 - ARM non-secure (non-invasive) debug enable"]
    #[inline(always)]
    pub fn niden(&mut self) -> NIDEN_W {
        NIDEN_W { w: self }
    }
    #[doc = "Bit 1 - ARM invasive debug enable"]
    #[inline(always)]
    pub fn dbg_en(&mut self) -> DBG_EN_W {
        DBG_EN_W { w: self }
    }
    #[doc = "Bit 2 - Security error response enable for all security gaskets (on both AHB and AXI buses)"]
    #[inline(always)]
    pub fn sec_err_resp(&mut self) -> SEC_ERR_RESP_W {
        SEC_ERR_RESP_W { w: self }
    }
    #[doc = "Bit 4 - DCP Key selection bit."]
    #[inline(always)]
    pub fn dcpkey_ocotp_or_keymux(&mut self) -> DCPKEY_OCOTP_OR_KEYMUX_W {
        DCPKEY_OCOTP_OR_KEYMUX_W { w: self }
    }
    #[doc = "Bit 8 - OCRAM TrustZone (TZ) enable."]
    #[inline(always)]
    pub fn ocram_tz_en(&mut self) -> OCRAM_TZ_EN_W {
        OCRAM_TZ_EN_W { w: self }
    }
    #[doc = "Bits 9:15 - OCRAM TrustZone (TZ) start address"]
    #[inline(always)]
    pub fn ocram_tz_addr(&mut self) -> OCRAM_TZ_ADDR_W {
        OCRAM_TZ_ADDR_W { w: self }
    }
    #[doc = "Bit 16 - Lock NIDEN field for changes"]
    #[inline(always)]
    pub fn lock_niden(&mut self) -> LOCK_NIDEN_W {
        LOCK_NIDEN_W { w: self }
    }
    #[doc = "Bit 17 - Lock DBG_EN field for changes"]
    #[inline(always)]
    pub fn lock_dbg_en(&mut self) -> LOCK_DBG_EN_W {
        LOCK_DBG_EN_W { w: self }
    }
    #[doc = "Bit 18 - Lock SEC_ERR_RESP field for changes"]
    #[inline(always)]
    pub fn lock_sec_err_resp(&mut self) -> LOCK_SEC_ERR_RESP_W {
        LOCK_SEC_ERR_RESP_W { w: self }
    }
    #[doc = "Bit 20 - Lock DCP Key OCOTP/Key MUX selection bit"]
    #[inline(always)]
    pub fn lock_dcpkey_ocotp_or_keymux(&mut self) -> LOCK_DCPKEY_OCOTP_OR_KEYMUX_W {
        LOCK_DCPKEY_OCOTP_OR_KEYMUX_W { w: self }
    }
    #[doc = "Bit 24 - Lock OCRAM_TZ_EN field for changes"]
    #[inline(always)]
    pub fn lock_ocram_tz_en(&mut self) -> LOCK_OCRAM_TZ_EN_W {
        LOCK_OCRAM_TZ_EN_W { w: self }
    }
    #[doc = "Bits 25:31 - Lock OCRAM_TZ_ADDR field for changes"]
    #[inline(always)]
    pub fn lock_ocram_tz_addr(&mut self) -> LOCK_OCRAM_TZ_ADDR_W {
        LOCK_OCRAM_TZ_ADDR_W { w: self }
    }
}