#[doc = "Register `MERRWARN` reader"]
pub type R = crate::R<MerrwarnSpec>;
#[doc = "Register `MERRWARN` writer"]
pub type W = crate::W<MerrwarnSpec>;
#[doc = "Underrun Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Urun {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Urun> for bool {
    #[inline(always)]
    fn from(variant: Urun) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `URUN` reader - Underrun Error Flag"]
pub type UrunR = crate::BitReader<Urun>;
impl UrunR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Urun {
        match self.bits {
            false => Urun::NoError,
            true => Urun::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Urun::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Urun::Error
    }
}
#[doc = "Field `URUN` writer - Underrun Error Flag"]
pub type UrunW<'a, REG> = crate::BitWriter1C<'a, REG, Urun>;
impl<'a, REG> UrunW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Urun::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Urun::Error)
    }
}
#[doc = "Not Acknowledge Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Nack {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Nack> for bool {
    #[inline(always)]
    fn from(variant: Nack) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `NACK` reader - Not Acknowledge Error Flag"]
pub type NackR = crate::BitReader<Nack>;
impl NackR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Nack {
        match self.bits {
            false => Nack::NoError,
            true => Nack::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Nack::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Nack::Error
    }
}
#[doc = "Field `NACK` writer - Not Acknowledge Error Flag"]
pub type NackW<'a, REG> = crate::BitWriter1C<'a, REG, Nack>;
impl<'a, REG> NackW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Nack::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Nack::Error)
    }
}
#[doc = "Write Abort Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Wrabt {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Wrabt> for bool {
    #[inline(always)]
    fn from(variant: Wrabt) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `WRABT` reader - Write Abort Error Flag"]
pub type WrabtR = crate::BitReader<Wrabt>;
impl WrabtR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Wrabt {
        match self.bits {
            false => Wrabt::NoError,
            true => Wrabt::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Wrabt::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Wrabt::Error
    }
}
#[doc = "Field `WRABT` writer - Write Abort Error Flag"]
pub type WrabtW<'a, REG> = crate::BitWriter1C<'a, REG, Wrabt>;
impl<'a, REG> WrabtW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Wrabt::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Wrabt::Error)
    }
}
#[doc = "Terminate Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Term {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Term> for bool {
    #[inline(always)]
    fn from(variant: Term) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `TERM` reader - Terminate Error Flag"]
pub type TermR = crate::BitReader<Term>;
impl TermR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Term {
        match self.bits {
            false => Term::NoError,
            true => Term::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Term::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Term::Error
    }
}
#[doc = "Field `TERM` writer - Terminate Error Flag"]
pub type TermW<'a, REG> = crate::BitWriter1C<'a, REG, Term>;
impl<'a, REG> TermW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Term::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Term::Error)
    }
}
#[doc = "High Data Rate Parity Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Hpar {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Hpar> for bool {
    #[inline(always)]
    fn from(variant: Hpar) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `HPAR` reader - High Data Rate Parity Flag"]
pub type HparR = crate::BitReader<Hpar>;
impl HparR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Hpar {
        match self.bits {
            false => Hpar::NoError,
            true => Hpar::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Hpar::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Hpar::Error
    }
}
#[doc = "Field `HPAR` writer - High Data Rate Parity Flag"]
pub type HparW<'a, REG> = crate::BitWriter1C<'a, REG, Hpar>;
impl<'a, REG> HparW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Hpar::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Hpar::Error)
    }
}
#[doc = "High Data Rate CRC Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Hcrc {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Hcrc> for bool {
    #[inline(always)]
    fn from(variant: Hcrc) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `HCRC` reader - High Data Rate CRC Error Flag"]
pub type HcrcR = crate::BitReader<Hcrc>;
impl HcrcR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Hcrc {
        match self.bits {
            false => Hcrc::NoError,
            true => Hcrc::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Hcrc::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Hcrc::Error
    }
}
#[doc = "Field `HCRC` writer - High Data Rate CRC Error Flag"]
pub type HcrcW<'a, REG> = crate::BitWriter1C<'a, REG, Hcrc>;
impl<'a, REG> HcrcW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Hcrc::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Hcrc::Error)
    }
}
#[doc = "Overread Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Oread {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Oread> for bool {
    #[inline(always)]
    fn from(variant: Oread) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OREAD` reader - Overread Error Flag"]
pub type OreadR = crate::BitReader<Oread>;
impl OreadR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Oread {
        match self.bits {
            false => Oread::NoError,
            true => Oread::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Oread::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Oread::Error
    }
}
#[doc = "Field `OREAD` writer - Overread Error Flag"]
pub type OreadW<'a, REG> = crate::BitWriter1C<'a, REG, Oread>;
impl<'a, REG> OreadW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Oread::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Oread::Error)
    }
}
#[doc = "Overwrite Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Owrite {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Owrite> for bool {
    #[inline(always)]
    fn from(variant: Owrite) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `OWRITE` reader - Overwrite Error Flag"]
pub type OwriteR = crate::BitReader<Owrite>;
impl OwriteR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Owrite {
        match self.bits {
            false => Owrite::NoError,
            true => Owrite::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Owrite::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Owrite::Error
    }
}
#[doc = "Field `OWRITE` writer - Overwrite Error Flag"]
pub type OwriteW<'a, REG> = crate::BitWriter1C<'a, REG, Owrite>;
impl<'a, REG> OwriteW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Owrite::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Owrite::Error)
    }
}
#[doc = "Message Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Msgerr {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Msgerr> for bool {
    #[inline(always)]
    fn from(variant: Msgerr) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `MSGERR` reader - Message Error Flag"]
pub type MsgerrR = crate::BitReader<Msgerr>;
impl MsgerrR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Msgerr {
        match self.bits {
            false => Msgerr::NoError,
            true => Msgerr::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Msgerr::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Msgerr::Error
    }
}
#[doc = "Field `MSGERR` writer - Message Error Flag"]
pub type MsgerrW<'a, REG> = crate::BitWriter1C<'a, REG, Msgerr>;
impl<'a, REG> MsgerrW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Msgerr::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Msgerr::Error)
    }
}
#[doc = "Invalid Request Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Invreq {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Invreq> for bool {
    #[inline(always)]
    fn from(variant: Invreq) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `INVREQ` reader - Invalid Request Error Flag"]
pub type InvreqR = crate::BitReader<Invreq>;
impl InvreqR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Invreq {
        match self.bits {
            false => Invreq::NoError,
            true => Invreq::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Invreq::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Invreq::Error
    }
}
#[doc = "Field `INVREQ` writer - Invalid Request Error Flag"]
pub type InvreqW<'a, REG> = crate::BitWriter1C<'a, REG, Invreq>;
impl<'a, REG> InvreqW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Invreq::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Invreq::Error)
    }
}
#[doc = "Timeout Error Flag\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Timeout {
    #[doc = "0: No error"]
    NoError = 0,
    #[doc = "1: Error"]
    Error = 1,
}
impl From<Timeout> for bool {
    #[inline(always)]
    fn from(variant: Timeout) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `TIMEOUT` reader - Timeout Error Flag"]
pub type TimeoutR = crate::BitReader<Timeout>;
impl TimeoutR {
    #[doc = "Get enumerated values variant"]
    #[inline(always)]
    pub const fn variant(&self) -> Timeout {
        match self.bits {
            false => Timeout::NoError,
            true => Timeout::Error,
        }
    }
    #[doc = "No error"]
    #[inline(always)]
    pub fn is_no_error(&self) -> bool {
        *self == Timeout::NoError
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn is_error(&self) -> bool {
        *self == Timeout::Error
    }
}
#[doc = "Field `TIMEOUT` writer - Timeout Error Flag"]
pub type TimeoutW<'a, REG> = crate::BitWriter1C<'a, REG, Timeout>;
impl<'a, REG> TimeoutW<'a, REG>
where
    REG: crate::Writable + crate::RegisterSpec,
{
    #[doc = "No error"]
    #[inline(always)]
    pub fn no_error(self) -> &'a mut crate::W<REG> {
        self.variant(Timeout::NoError)
    }
    #[doc = "Error"]
    #[inline(always)]
    pub fn error(self) -> &'a mut crate::W<REG> {
        self.variant(Timeout::Error)
    }
}
impl R {
    #[doc = "Bit 1 - Underrun Error Flag"]
    #[inline(always)]
    pub fn urun(&self) -> UrunR {
        UrunR::new(((self.bits >> 1) & 1) != 0)
    }
    #[doc = "Bit 2 - Not Acknowledge Error Flag"]
    #[inline(always)]
    pub fn nack(&self) -> NackR {
        NackR::new(((self.bits >> 2) & 1) != 0)
    }
    #[doc = "Bit 3 - Write Abort Error Flag"]
    #[inline(always)]
    pub fn wrabt(&self) -> WrabtR {
        WrabtR::new(((self.bits >> 3) & 1) != 0)
    }
    #[doc = "Bit 4 - Terminate Error Flag"]
    #[inline(always)]
    pub fn term(&self) -> TermR {
        TermR::new(((self.bits >> 4) & 1) != 0)
    }
    #[doc = "Bit 9 - High Data Rate Parity Flag"]
    #[inline(always)]
    pub fn hpar(&self) -> HparR {
        HparR::new(((self.bits >> 9) & 1) != 0)
    }
    #[doc = "Bit 10 - High Data Rate CRC Error Flag"]
    #[inline(always)]
    pub fn hcrc(&self) -> HcrcR {
        HcrcR::new(((self.bits >> 10) & 1) != 0)
    }
    #[doc = "Bit 16 - Overread Error Flag"]
    #[inline(always)]
    pub fn oread(&self) -> OreadR {
        OreadR::new(((self.bits >> 16) & 1) != 0)
    }
    #[doc = "Bit 17 - Overwrite Error Flag"]
    #[inline(always)]
    pub fn owrite(&self) -> OwriteR {
        OwriteR::new(((self.bits >> 17) & 1) != 0)
    }
    #[doc = "Bit 18 - Message Error Flag"]
    #[inline(always)]
    pub fn msgerr(&self) -> MsgerrR {
        MsgerrR::new(((self.bits >> 18) & 1) != 0)
    }
    #[doc = "Bit 19 - Invalid Request Error Flag"]
    #[inline(always)]
    pub fn invreq(&self) -> InvreqR {
        InvreqR::new(((self.bits >> 19) & 1) != 0)
    }
    #[doc = "Bit 20 - Timeout Error Flag"]
    #[inline(always)]
    pub fn timeout(&self) -> TimeoutR {
        TimeoutR::new(((self.bits >> 20) & 1) != 0)
    }
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("MERRWARN")
            .field("urun", &self.urun())
            .field("nack", &self.nack())
            .field("wrabt", &self.wrabt())
            .field("term", &self.term())
            .field("hpar", &self.hpar())
            .field("hcrc", &self.hcrc())
            .field("oread", &self.oread())
            .field("owrite", &self.owrite())
            .field("msgerr", &self.msgerr())
            .field("invreq", &self.invreq())
            .field("timeout", &self.timeout())
            .finish()
    }
}
impl W {
    #[doc = "Bit 1 - Underrun Error Flag"]
    #[inline(always)]
    pub fn urun(&mut self) -> UrunW<'_, MerrwarnSpec> {
        UrunW::new(self, 1)
    }
    #[doc = "Bit 2 - Not Acknowledge Error Flag"]
    #[inline(always)]
    pub fn nack(&mut self) -> NackW<'_, MerrwarnSpec> {
        NackW::new(self, 2)
    }
    #[doc = "Bit 3 - Write Abort Error Flag"]
    #[inline(always)]
    pub fn wrabt(&mut self) -> WrabtW<'_, MerrwarnSpec> {
        WrabtW::new(self, 3)
    }
    #[doc = "Bit 4 - Terminate Error Flag"]
    #[inline(always)]
    pub fn term(&mut self) -> TermW<'_, MerrwarnSpec> {
        TermW::new(self, 4)
    }
    #[doc = "Bit 9 - High Data Rate Parity Flag"]
    #[inline(always)]
    pub fn hpar(&mut self) -> HparW<'_, MerrwarnSpec> {
        HparW::new(self, 9)
    }
    #[doc = "Bit 10 - High Data Rate CRC Error Flag"]
    #[inline(always)]
    pub fn hcrc(&mut self) -> HcrcW<'_, MerrwarnSpec> {
        HcrcW::new(self, 10)
    }
    #[doc = "Bit 16 - Overread Error Flag"]
    #[inline(always)]
    pub fn oread(&mut self) -> OreadW<'_, MerrwarnSpec> {
        OreadW::new(self, 16)
    }
    #[doc = "Bit 17 - Overwrite Error Flag"]
    #[inline(always)]
    pub fn owrite(&mut self) -> OwriteW<'_, MerrwarnSpec> {
        OwriteW::new(self, 17)
    }
    #[doc = "Bit 18 - Message Error Flag"]
    #[inline(always)]
    pub fn msgerr(&mut self) -> MsgerrW<'_, MerrwarnSpec> {
        MsgerrW::new(self, 18)
    }
    #[doc = "Bit 19 - Invalid Request Error Flag"]
    #[inline(always)]
    pub fn invreq(&mut self) -> InvreqW<'_, MerrwarnSpec> {
        InvreqW::new(self, 19)
    }
    #[doc = "Bit 20 - Timeout Error Flag"]
    #[inline(always)]
    pub fn timeout(&mut self) -> TimeoutW<'_, MerrwarnSpec> {
        TimeoutW::new(self, 20)
    }
}
#[doc = "Controller Errors and Warnings\n\nYou can [`read`](crate::Reg::read) this register and get [`merrwarn::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`merrwarn::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct MerrwarnSpec;
impl crate::RegisterSpec for MerrwarnSpec {
    type Ux = u32;
}
#[doc = "`read()` method returns [`merrwarn::R`](R) reader structure"]
impl crate::Readable for MerrwarnSpec {}
#[doc = "`write(|w| ..)` method takes [`merrwarn::W`](W) writer structure"]
impl crate::Writable for MerrwarnSpec {
    type Safety = crate::Unsafe;
    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0x001f_061e;
}
#[doc = "`reset()` method sets MERRWARN to value 0"]
impl crate::Resettable for MerrwarnSpec {}
