#[doc = "Register `STATUS` reader"]
pub struct R(crate::R<STATUS_SPEC>);
impl core::ops::Deref for R {
    type Target = crate::R<STATUS_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl core::convert::From<crate::R<STATUS_SPEC>> for R {
    fn from(reader: crate::R<STATUS_SPEC>) -> Self {
        R(reader)
    }
}
#[doc = "Register `STATUS` writer"]
pub struct W(crate::W<STATUS_SPEC>);
impl core::ops::Deref for W {
    type Target = crate::W<STATUS_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl core::ops::DerefMut for W {
    #[inline(always)]
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}
impl core::convert::From<crate::W<STATUS_SPEC>> for W {
    fn from(writer: crate::W<STATUS_SPEC>) -> Self {
        W(writer)
    }
}
#[doc = "Field `TXD` reader - "]
pub struct TXD_R(crate::FieldReader<bool, bool>);
impl TXD_R {
    pub(crate) fn new(bits: bool) -> Self {
        TXD_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for TXD_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `TXD` writer - "]
pub struct TXD_W<'a> {
    w: &'a mut W,
}
impl<'a> TXD_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 << 31)) | (((value as u32) & 0x01) << 31);
        self.w
    }
}
#[doc = "Field `RTSN` reader - "]
pub struct RTSN_R(crate::FieldReader<bool, bool>);
impl RTSN_R {
    pub(crate) fn new(bits: bool) -> Self {
        RTSN_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for RTSN_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `RTSN` writer - "]
pub struct RTSN_W<'a> {
    w: &'a mut W,
}
impl<'a> RTSN_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 << 30)) | (((value as u32) & 0x01) << 30);
        self.w
    }
}
#[doc = "Field `DTRN` reader - "]
pub struct DTRN_R(crate::FieldReader<bool, bool>);
impl DTRN_R {
    pub(crate) fn new(bits: bool) -> Self {
        DTRN_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for DTRN_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `DTRN` writer - "]
pub struct DTRN_W<'a> {
    w: &'a mut W,
}
impl<'a> DTRN_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 << 29)) | (((value as u32) & 0x01) << 29);
        self.w
    }
}
#[doc = "\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum ST_UTX_OUT_A {
    #[doc = "0: TX_IDLE"]
    TX_IDLE = 0,
    #[doc = "1: TX_STRT"]
    TX_STRT = 1,
    #[doc = "2: TX_DAT0"]
    TX_DAT0 = 2,
    #[doc = "3: TX_DAT1"]
    TX_DAT1 = 3,
    #[doc = "4: TX_DAT2"]
    TX_DAT2 = 4,
    #[doc = "5: TX_DAT3"]
    TX_DAT3 = 5,
    #[doc = "6: TX_DAT4"]
    TX_DAT4 = 6,
    #[doc = "7: TX_DAT5"]
    TX_DAT5 = 7,
    #[doc = "8: TX_DAT6"]
    TX_DAT6 = 8,
    #[doc = "9: TX_DAT7"]
    TX_DAT7 = 9,
    #[doc = "10: TX_PRTY"]
    TX_PRTY = 10,
    #[doc = "11: TX_STP1"]
    TX_STP1 = 11,
    #[doc = "12: TX_STP2"]
    TX_STP2 = 12,
    #[doc = "14: TX_DL1"]
    TX_DL1 = 14,
}
impl From<ST_UTX_OUT_A> for u8 {
    #[inline(always)]
    fn from(variant: ST_UTX_OUT_A) -> Self {
        variant as _
    }
}
#[doc = "Field `ST_UTX_OUT` reader - "]
pub struct ST_UTX_OUT_R(crate::FieldReader<u8, ST_UTX_OUT_A>);
impl ST_UTX_OUT_R {
    pub(crate) fn new(bits: u8) -> Self {
        ST_UTX_OUT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> crate::Variant<u8, ST_UTX_OUT_A> {
        use crate::Variant::*;
        match self.bits {
            0 => Val(ST_UTX_OUT_A::TX_IDLE),
            1 => Val(ST_UTX_OUT_A::TX_STRT),
            2 => Val(ST_UTX_OUT_A::TX_DAT0),
            3 => Val(ST_UTX_OUT_A::TX_DAT1),
            4 => Val(ST_UTX_OUT_A::TX_DAT2),
            5 => Val(ST_UTX_OUT_A::TX_DAT3),
            6 => Val(ST_UTX_OUT_A::TX_DAT4),
            7 => Val(ST_UTX_OUT_A::TX_DAT5),
            8 => Val(ST_UTX_OUT_A::TX_DAT6),
            9 => Val(ST_UTX_OUT_A::TX_DAT7),
            10 => Val(ST_UTX_OUT_A::TX_PRTY),
            11 => Val(ST_UTX_OUT_A::TX_STP1),
            12 => Val(ST_UTX_OUT_A::TX_STP2),
            14 => Val(ST_UTX_OUT_A::TX_DL1),
            i => Res(i),
        }
    }
    #[doc = "Checks if the value of the field is `TX_IDLE`"]
    #[inline(always)]
    pub fn is_tx_idle(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_IDLE
    }
    #[doc = "Checks if the value of the field is `TX_STRT`"]
    #[inline(always)]
    pub fn is_tx_strt(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_STRT
    }
    #[doc = "Checks if the value of the field is `TX_DAT0`"]
    #[inline(always)]
    pub fn is_tx_dat0(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT0
    }
    #[doc = "Checks if the value of the field is `TX_DAT1`"]
    #[inline(always)]
    pub fn is_tx_dat1(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT1
    }
    #[doc = "Checks if the value of the field is `TX_DAT2`"]
    #[inline(always)]
    pub fn is_tx_dat2(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT2
    }
    #[doc = "Checks if the value of the field is `TX_DAT3`"]
    #[inline(always)]
    pub fn is_tx_dat3(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT3
    }
    #[doc = "Checks if the value of the field is `TX_DAT4`"]
    #[inline(always)]
    pub fn is_tx_dat4(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT4
    }
    #[doc = "Checks if the value of the field is `TX_DAT5`"]
    #[inline(always)]
    pub fn is_tx_dat5(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT5
    }
    #[doc = "Checks if the value of the field is `TX_DAT6`"]
    #[inline(always)]
    pub fn is_tx_dat6(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT6
    }
    #[doc = "Checks if the value of the field is `TX_DAT7`"]
    #[inline(always)]
    pub fn is_tx_dat7(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DAT7
    }
    #[doc = "Checks if the value of the field is `TX_PRTY`"]
    #[inline(always)]
    pub fn is_tx_prty(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_PRTY
    }
    #[doc = "Checks if the value of the field is `TX_STP1`"]
    #[inline(always)]
    pub fn is_tx_stp1(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_STP1
    }
    #[doc = "Checks if the value of the field is `TX_STP2`"]
    #[inline(always)]
    pub fn is_tx_stp2(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_STP2
    }
    #[doc = "Checks if the value of the field is `TX_DL1`"]
    #[inline(always)]
    pub fn is_tx_dl1(&self) -> bool {
        **self == ST_UTX_OUT_A::TX_DL1
    }
}
impl core::ops::Deref for ST_UTX_OUT_R {
    type Target = crate::FieldReader<u8, ST_UTX_OUT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `ST_UTX_OUT` writer - "]
pub struct ST_UTX_OUT_W<'a> {
    w: &'a mut W,
}
impl<'a> ST_UTX_OUT_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: ST_UTX_OUT_A) -> &'a mut W {
        unsafe { self.bits(variant.into()) }
    }
    #[doc = "TX_IDLE"]
    #[inline(always)]
    pub fn tx_idle(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_IDLE)
    }
    #[doc = "TX_STRT"]
    #[inline(always)]
    pub fn tx_strt(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_STRT)
    }
    #[doc = "TX_DAT0"]
    #[inline(always)]
    pub fn tx_dat0(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT0)
    }
    #[doc = "TX_DAT1"]
    #[inline(always)]
    pub fn tx_dat1(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT1)
    }
    #[doc = "TX_DAT2"]
    #[inline(always)]
    pub fn tx_dat2(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT2)
    }
    #[doc = "TX_DAT3"]
    #[inline(always)]
    pub fn tx_dat3(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT3)
    }
    #[doc = "TX_DAT4"]
    #[inline(always)]
    pub fn tx_dat4(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT4)
    }
    #[doc = "TX_DAT5"]
    #[inline(always)]
    pub fn tx_dat5(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT5)
    }
    #[doc = "TX_DAT6"]
    #[inline(always)]
    pub fn tx_dat6(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT6)
    }
    #[doc = "TX_DAT7"]
    #[inline(always)]
    pub fn tx_dat7(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DAT7)
    }
    #[doc = "TX_PRTY"]
    #[inline(always)]
    pub fn tx_prty(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_PRTY)
    }
    #[doc = "TX_STP1"]
    #[inline(always)]
    pub fn tx_stp1(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_STP1)
    }
    #[doc = "TX_STP2"]
    #[inline(always)]
    pub fn tx_stp2(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_STP2)
    }
    #[doc = "TX_DL1"]
    #[inline(always)]
    pub fn tx_dl1(self) -> &'a mut W {
        self.variant(ST_UTX_OUT_A::TX_DL1)
    }
    #[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 & !(0x0f << 24)) | (((value as u32) & 0x0f) << 24);
        self.w
    }
}
#[doc = "Field `TXFIFO_CNT` reader - "]
pub struct TXFIFO_CNT_R(crate::FieldReader<u8, u8>);
impl TXFIFO_CNT_R {
    pub(crate) fn new(bits: u8) -> Self {
        TXFIFO_CNT_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for TXFIFO_CNT_R {
    type Target = crate::FieldReader<u8, u8>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `TXFIFO_CNT` writer - "]
pub struct TXFIFO_CNT_W<'a> {
    w: &'a mut W,
}
impl<'a> TXFIFO_CNT_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 & !(0xff << 16)) | (((value as u32) & 0xff) << 16);
        self.w
    }
}
#[doc = "Field `RXD` reader - "]
pub struct RXD_R(crate::FieldReader<bool, bool>);
impl RXD_R {
    pub(crate) fn new(bits: bool) -> Self {
        RXD_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for RXD_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `RXD` writer - "]
pub struct RXD_W<'a> {
    w: &'a mut W,
}
impl<'a> RXD_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 << 15)) | (((value as u32) & 0x01) << 15);
        self.w
    }
}
#[doc = "Field `CTSN` reader - "]
pub struct CTSN_R(crate::FieldReader<bool, bool>);
impl CTSN_R {
    pub(crate) fn new(bits: bool) -> Self {
        CTSN_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for CTSN_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `CTSN` writer - "]
pub struct CTSN_W<'a> {
    w: &'a mut W,
}
impl<'a> CTSN_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 << 14)) | (((value as u32) & 0x01) << 14);
        self.w
    }
}
#[doc = "Field `DSRN` reader - "]
pub struct DSRN_R(crate::FieldReader<bool, bool>);
impl DSRN_R {
    pub(crate) fn new(bits: bool) -> Self {
        DSRN_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for DSRN_R {
    type Target = crate::FieldReader<bool, bool>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `DSRN` writer - "]
pub struct DSRN_W<'a> {
    w: &'a mut W,
}
impl<'a> DSRN_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 << 13)) | (((value as u32) & 0x01) << 13);
        self.w
    }
}
#[doc = "\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
#[repr(u8)]
pub enum ST_URX_OUT_A {
    #[doc = "0: RX_IDLE"]
    RX_IDLE = 0,
    #[doc = "1: RX_STRT"]
    RX_STRT = 1,
    #[doc = "2: RX_DAT0"]
    RX_DAT0 = 2,
    #[doc = "3: RX_DAT1"]
    RX_DAT1 = 3,
    #[doc = "4: RX_DAT2"]
    RX_DAT2 = 4,
    #[doc = "5: RX_DAT3"]
    RX_DAT3 = 5,
    #[doc = "6: RX_DAT4"]
    RX_DAT4 = 6,
    #[doc = "7: RX_DAT5"]
    RX_DAT5 = 7,
    #[doc = "8: RX_DAT6"]
    RX_DAT6 = 8,
    #[doc = "9: RX_DAT7"]
    RX_DAT7 = 9,
    #[doc = "10: RX_PRTY"]
    RX_PRTY = 10,
    #[doc = "11: RX_STP1"]
    RX_STP1 = 11,
    #[doc = "12: RX_STP2"]
    RX_STP2 = 12,
    #[doc = "13: RX_DL1"]
    RX_DL1 = 13,
}
impl From<ST_URX_OUT_A> for u8 {
    #[inline(always)]
    fn from(variant: ST_URX_OUT_A) -> Self {
        variant as _
    }
}
#[doc = "Field `ST_URX_OUT` reader - "]
pub struct ST_URX_OUT_R(crate::FieldReader<u8, ST_URX_OUT_A>);
impl ST_URX_OUT_R {
    pub(crate) fn new(bits: u8) -> Self {
        ST_URX_OUT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> crate::Variant<u8, ST_URX_OUT_A> {
        use crate::Variant::*;
        match self.bits {
            0 => Val(ST_URX_OUT_A::RX_IDLE),
            1 => Val(ST_URX_OUT_A::RX_STRT),
            2 => Val(ST_URX_OUT_A::RX_DAT0),
            3 => Val(ST_URX_OUT_A::RX_DAT1),
            4 => Val(ST_URX_OUT_A::RX_DAT2),
            5 => Val(ST_URX_OUT_A::RX_DAT3),
            6 => Val(ST_URX_OUT_A::RX_DAT4),
            7 => Val(ST_URX_OUT_A::RX_DAT5),
            8 => Val(ST_URX_OUT_A::RX_DAT6),
            9 => Val(ST_URX_OUT_A::RX_DAT7),
            10 => Val(ST_URX_OUT_A::RX_PRTY),
            11 => Val(ST_URX_OUT_A::RX_STP1),
            12 => Val(ST_URX_OUT_A::RX_STP2),
            13 => Val(ST_URX_OUT_A::RX_DL1),
            i => Res(i),
        }
    }
    #[doc = "Checks if the value of the field is `RX_IDLE`"]
    #[inline(always)]
    pub fn is_rx_idle(&self) -> bool {
        **self == ST_URX_OUT_A::RX_IDLE
    }
    #[doc = "Checks if the value of the field is `RX_STRT`"]
    #[inline(always)]
    pub fn is_rx_strt(&self) -> bool {
        **self == ST_URX_OUT_A::RX_STRT
    }
    #[doc = "Checks if the value of the field is `RX_DAT0`"]
    #[inline(always)]
    pub fn is_rx_dat0(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT0
    }
    #[doc = "Checks if the value of the field is `RX_DAT1`"]
    #[inline(always)]
    pub fn is_rx_dat1(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT1
    }
    #[doc = "Checks if the value of the field is `RX_DAT2`"]
    #[inline(always)]
    pub fn is_rx_dat2(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT2
    }
    #[doc = "Checks if the value of the field is `RX_DAT3`"]
    #[inline(always)]
    pub fn is_rx_dat3(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT3
    }
    #[doc = "Checks if the value of the field is `RX_DAT4`"]
    #[inline(always)]
    pub fn is_rx_dat4(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT4
    }
    #[doc = "Checks if the value of the field is `RX_DAT5`"]
    #[inline(always)]
    pub fn is_rx_dat5(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT5
    }
    #[doc = "Checks if the value of the field is `RX_DAT6`"]
    #[inline(always)]
    pub fn is_rx_dat6(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT6
    }
    #[doc = "Checks if the value of the field is `RX_DAT7`"]
    #[inline(always)]
    pub fn is_rx_dat7(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DAT7
    }
    #[doc = "Checks if the value of the field is `RX_PRTY`"]
    #[inline(always)]
    pub fn is_rx_prty(&self) -> bool {
        **self == ST_URX_OUT_A::RX_PRTY
    }
    #[doc = "Checks if the value of the field is `RX_STP1`"]
    #[inline(always)]
    pub fn is_rx_stp1(&self) -> bool {
        **self == ST_URX_OUT_A::RX_STP1
    }
    #[doc = "Checks if the value of the field is `RX_STP2`"]
    #[inline(always)]
    pub fn is_rx_stp2(&self) -> bool {
        **self == ST_URX_OUT_A::RX_STP2
    }
    #[doc = "Checks if the value of the field is `RX_DL1`"]
    #[inline(always)]
    pub fn is_rx_dl1(&self) -> bool {
        **self == ST_URX_OUT_A::RX_DL1
    }
}
impl core::ops::Deref for ST_URX_OUT_R {
    type Target = crate::FieldReader<u8, ST_URX_OUT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `ST_URX_OUT` writer - "]
pub struct ST_URX_OUT_W<'a> {
    w: &'a mut W,
}
impl<'a> ST_URX_OUT_W<'a> {
    #[doc = r"Writes `variant` to the field"]
    #[inline(always)]
    pub fn variant(self, variant: ST_URX_OUT_A) -> &'a mut W {
        unsafe { self.bits(variant.into()) }
    }
    #[doc = "RX_IDLE"]
    #[inline(always)]
    pub fn rx_idle(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_IDLE)
    }
    #[doc = "RX_STRT"]
    #[inline(always)]
    pub fn rx_strt(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_STRT)
    }
    #[doc = "RX_DAT0"]
    #[inline(always)]
    pub fn rx_dat0(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT0)
    }
    #[doc = "RX_DAT1"]
    #[inline(always)]
    pub fn rx_dat1(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT1)
    }
    #[doc = "RX_DAT2"]
    #[inline(always)]
    pub fn rx_dat2(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT2)
    }
    #[doc = "RX_DAT3"]
    #[inline(always)]
    pub fn rx_dat3(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT3)
    }
    #[doc = "RX_DAT4"]
    #[inline(always)]
    pub fn rx_dat4(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT4)
    }
    #[doc = "RX_DAT5"]
    #[inline(always)]
    pub fn rx_dat5(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT5)
    }
    #[doc = "RX_DAT6"]
    #[inline(always)]
    pub fn rx_dat6(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT6)
    }
    #[doc = "RX_DAT7"]
    #[inline(always)]
    pub fn rx_dat7(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DAT7)
    }
    #[doc = "RX_PRTY"]
    #[inline(always)]
    pub fn rx_prty(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_PRTY)
    }
    #[doc = "RX_STP1"]
    #[inline(always)]
    pub fn rx_stp1(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_STP1)
    }
    #[doc = "RX_STP2"]
    #[inline(always)]
    pub fn rx_stp2(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_STP2)
    }
    #[doc = "RX_DL1"]
    #[inline(always)]
    pub fn rx_dl1(self) -> &'a mut W {
        self.variant(ST_URX_OUT_A::RX_DL1)
    }
    #[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 & !(0x0f << 8)) | (((value as u32) & 0x0f) << 8);
        self.w
    }
}
#[doc = "Field `RXFIFO_CNT` reader - "]
pub struct RXFIFO_CNT_R(crate::FieldReader<u8, u8>);
impl RXFIFO_CNT_R {
    pub(crate) fn new(bits: u8) -> Self {
        RXFIFO_CNT_R(crate::FieldReader::new(bits))
    }
}
impl core::ops::Deref for RXFIFO_CNT_R {
    type Target = crate::FieldReader<u8, u8>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "Field `RXFIFO_CNT` writer - "]
pub struct RXFIFO_CNT_W<'a> {
    w: &'a mut W,
}
impl<'a> RXFIFO_CNT_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 & !0xff) | ((value as u32) & 0xff);
        self.w
    }
}
impl R {
    #[doc = "Bit 31"]
    #[inline(always)]
    pub fn txd(&self) -> TXD_R {
        TXD_R::new(((self.bits >> 31) & 0x01) != 0)
    }
    #[doc = "Bit 30"]
    #[inline(always)]
    pub fn rtsn(&self) -> RTSN_R {
        RTSN_R::new(((self.bits >> 30) & 0x01) != 0)
    }
    #[doc = "Bit 29"]
    #[inline(always)]
    pub fn dtrn(&self) -> DTRN_R {
        DTRN_R::new(((self.bits >> 29) & 0x01) != 0)
    }
    #[doc = "Bits 24:27"]
    #[inline(always)]
    pub fn st_utx_out(&self) -> ST_UTX_OUT_R {
        ST_UTX_OUT_R::new(((self.bits >> 24) & 0x0f) as u8)
    }
    #[doc = "Bits 16:23"]
    #[inline(always)]
    pub fn txfifo_cnt(&self) -> TXFIFO_CNT_R {
        TXFIFO_CNT_R::new(((self.bits >> 16) & 0xff) as u8)
    }
    #[doc = "Bit 15"]
    #[inline(always)]
    pub fn rxd(&self) -> RXD_R {
        RXD_R::new(((self.bits >> 15) & 0x01) != 0)
    }
    #[doc = "Bit 14"]
    #[inline(always)]
    pub fn ctsn(&self) -> CTSN_R {
        CTSN_R::new(((self.bits >> 14) & 0x01) != 0)
    }
    #[doc = "Bit 13"]
    #[inline(always)]
    pub fn dsrn(&self) -> DSRN_R {
        DSRN_R::new(((self.bits >> 13) & 0x01) != 0)
    }
    #[doc = "Bits 8:11"]
    #[inline(always)]
    pub fn st_urx_out(&self) -> ST_URX_OUT_R {
        ST_URX_OUT_R::new(((self.bits >> 8) & 0x0f) as u8)
    }
    #[doc = "Bits 0:7"]
    #[inline(always)]
    pub fn rxfifo_cnt(&self) -> RXFIFO_CNT_R {
        RXFIFO_CNT_R::new((self.bits & 0xff) as u8)
    }
}
impl W {
    #[doc = "Bit 31"]
    #[inline(always)]
    pub fn txd(&mut self) -> TXD_W {
        TXD_W { w: self }
    }
    #[doc = "Bit 30"]
    #[inline(always)]
    pub fn rtsn(&mut self) -> RTSN_W {
        RTSN_W { w: self }
    }
    #[doc = "Bit 29"]
    #[inline(always)]
    pub fn dtrn(&mut self) -> DTRN_W {
        DTRN_W { w: self }
    }
    #[doc = "Bits 24:27"]
    #[inline(always)]
    pub fn st_utx_out(&mut self) -> ST_UTX_OUT_W {
        ST_UTX_OUT_W { w: self }
    }
    #[doc = "Bits 16:23"]
    #[inline(always)]
    pub fn txfifo_cnt(&mut self) -> TXFIFO_CNT_W {
        TXFIFO_CNT_W { w: self }
    }
    #[doc = "Bit 15"]
    #[inline(always)]
    pub fn rxd(&mut self) -> RXD_W {
        RXD_W { w: self }
    }
    #[doc = "Bit 14"]
    #[inline(always)]
    pub fn ctsn(&mut self) -> CTSN_W {
        CTSN_W { w: self }
    }
    #[doc = "Bit 13"]
    #[inline(always)]
    pub fn dsrn(&mut self) -> DSRN_W {
        DSRN_W { w: self }
    }
    #[doc = "Bits 8:11"]
    #[inline(always)]
    pub fn st_urx_out(&mut self) -> ST_URX_OUT_W {
        ST_URX_OUT_W { w: self }
    }
    #[doc = "Bits 0:7"]
    #[inline(always)]
    pub fn rxfifo_cnt(&mut self) -> RXFIFO_CNT_W {
        RXFIFO_CNT_W { w: self }
    }
    #[doc = "Writes raw bits to the register."]
    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
        self.0.bits(bits);
        self
    }
}
#[doc = "UART_STATUS\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [status](index.html) module"]
pub struct STATUS_SPEC;
impl crate::RegisterSpec for STATUS_SPEC {
    type Ux = u32;
}
#[doc = "`read()` method returns [status::R](R) reader structure"]
impl crate::Readable for STATUS_SPEC {
    type Reader = R;
}
#[doc = "`write(|w| ..)` method takes [status::W](W) writer structure"]
impl crate::Writable for STATUS_SPEC {
    type Writer = W;
}
#[doc = "`reset()` method sets STATUS to value 0"]
impl crate::Resettable for STATUS_SPEC {
    #[inline(always)]
    fn reset_value() -> Self::Ux {
        0
    }
}