#[doc = "Reader of register DMAIM"]
pub type R = crate::R<u32, super::DMAIM>;
#[doc = "Writer for register DMAIM"]
pub type W = crate::W<u32, super::DMAIM>;
#[doc = "Register DMAIM `reset()`'s with value 0"]
impl crate::ResetValue for super::DMAIM {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `TIE`"]
pub type TIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TIE`"]
pub struct TIE_W<'a> {
w: &'a mut W,
}
impl<'a> TIE_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 = "Reader of field `TSE`"]
pub type TSE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TSE`"]
pub struct TSE_W<'a> {
w: &'a mut W,
}
impl<'a> TSE_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 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `TUE`"]
pub type TUE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TUE`"]
pub struct TUE_W<'a> {
w: &'a mut W,
}
impl<'a> TUE_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 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `TJE`"]
pub type TJE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `TJE`"]
pub struct TJE_W<'a> {
w: &'a mut W,
}
impl<'a> TJE_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 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `OVE`"]
pub type OVE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `OVE`"]
pub struct OVE_W<'a> {
w: &'a mut W,
}
impl<'a> OVE_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 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `UNE`"]
pub type UNE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `UNE`"]
pub struct UNE_W<'a> {
w: &'a mut W,
}
impl<'a> UNE_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 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `RIE`"]
pub type RIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RIE`"]
pub struct RIE_W<'a> {
w: &'a mut W,
}
impl<'a> RIE_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 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `RUE`"]
pub type RUE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RUE`"]
pub struct RUE_W<'a> {
w: &'a mut W,
}
impl<'a> RUE_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 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `RSE`"]
pub type RSE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RSE`"]
pub struct RSE_W<'a> {
w: &'a mut W,
}
impl<'a> RSE_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 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `RWE`"]
pub type RWE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RWE`"]
pub struct RWE_W<'a> {
w: &'a mut W,
}
impl<'a> RWE_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 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `ETE`"]
pub type ETE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ETE`"]
pub struct ETE_W<'a> {
w: &'a mut W,
}
impl<'a> ETE_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 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `FBE`"]
pub type FBE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `FBE`"]
pub struct FBE_W<'a> {
w: &'a mut W,
}
impl<'a> FBE_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 = "Reader of field `ERE`"]
pub type ERE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ERE`"]
pub struct ERE_W<'a> {
w: &'a mut W,
}
impl<'a> ERE_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 = "Reader of field `AIE`"]
pub type AIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `AIE`"]
pub struct AIE_W<'a> {
w: &'a mut W,
}
impl<'a> AIE_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 = "Reader of field `NIE`"]
pub type NIE_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `NIE`"]
pub struct NIE_W<'a> {
w: &'a mut W,
}
impl<'a> NIE_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 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
impl R {
#[doc = "Bit 0 - Transmit Interrupt Enable"]
#[inline(always)]
pub fn tie(&self) -> TIE_R {
TIE_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Transmit Stopped Enable"]
#[inline(always)]
pub fn tse(&self) -> TSE_R {
TSE_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Transmit Buffer Unvailable Enable"]
#[inline(always)]
pub fn tue(&self) -> TUE_R {
TUE_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Transmit Jabber Timeout Enable"]
#[inline(always)]
pub fn tje(&self) -> TJE_R {
TJE_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Overflow Interrupt Enable"]
#[inline(always)]
pub fn ove(&self) -> OVE_R {
OVE_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Underflow Interrupt Enable"]
#[inline(always)]
pub fn une(&self) -> UNE_R {
UNE_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Receive Interrupt Enable"]
#[inline(always)]
pub fn rie(&self) -> RIE_R {
RIE_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - Receive Buffer Unavailable Enable"]
#[inline(always)]
pub fn rue(&self) -> RUE_R {
RUE_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - Receive Stopped Enable"]
#[inline(always)]
pub fn rse(&self) -> RSE_R {
RSE_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - Receive Watchdog Timeout Enable"]
#[inline(always)]
pub fn rwe(&self) -> RWE_R {
RWE_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Early Transmit Interrupt Enable"]
#[inline(always)]
pub fn ete(&self) -> ETE_R {
ETE_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 13 - Fatal Bus Error Enable"]
#[inline(always)]
pub fn fbe(&self) -> FBE_R {
FBE_R::new(((self.bits >> 13) & 0x01) != 0)
}
#[doc = "Bit 14 - Early Receive Interrupt Enable"]
#[inline(always)]
pub fn ere(&self) -> ERE_R {
ERE_R::new(((self.bits >> 14) & 0x01) != 0)
}
#[doc = "Bit 15 - Abnormal Interrupt Summary Enable"]
#[inline(always)]
pub fn aie(&self) -> AIE_R {
AIE_R::new(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bit 16 - Normal Interrupt Summary Enable"]
#[inline(always)]
pub fn nie(&self) -> NIE_R {
NIE_R::new(((self.bits >> 16) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - Transmit Interrupt Enable"]
#[inline(always)]
pub fn tie(&mut self) -> TIE_W {
TIE_W { w: self }
}
#[doc = "Bit 1 - Transmit Stopped Enable"]
#[inline(always)]
pub fn tse(&mut self) -> TSE_W {
TSE_W { w: self }
}
#[doc = "Bit 2 - Transmit Buffer Unvailable Enable"]
#[inline(always)]
pub fn tue(&mut self) -> TUE_W {
TUE_W { w: self }
}
#[doc = "Bit 3 - Transmit Jabber Timeout Enable"]
#[inline(always)]
pub fn tje(&mut self) -> TJE_W {
TJE_W { w: self }
}
#[doc = "Bit 4 - Overflow Interrupt Enable"]
#[inline(always)]
pub fn ove(&mut self) -> OVE_W {
OVE_W { w: self }
}
#[doc = "Bit 5 - Underflow Interrupt Enable"]
#[inline(always)]
pub fn une(&mut self) -> UNE_W {
UNE_W { w: self }
}
#[doc = "Bit 6 - Receive Interrupt Enable"]
#[inline(always)]
pub fn rie(&mut self) -> RIE_W {
RIE_W { w: self }
}
#[doc = "Bit 7 - Receive Buffer Unavailable Enable"]
#[inline(always)]
pub fn rue(&mut self) -> RUE_W {
RUE_W { w: self }
}
#[doc = "Bit 8 - Receive Stopped Enable"]
#[inline(always)]
pub fn rse(&mut self) -> RSE_W {
RSE_W { w: self }
}
#[doc = "Bit 9 - Receive Watchdog Timeout Enable"]
#[inline(always)]
pub fn rwe(&mut self) -> RWE_W {
RWE_W { w: self }
}
#[doc = "Bit 10 - Early Transmit Interrupt Enable"]
#[inline(always)]
pub fn ete(&mut self) -> ETE_W {
ETE_W { w: self }
}
#[doc = "Bit 13 - Fatal Bus Error Enable"]
#[inline(always)]
pub fn fbe(&mut self) -> FBE_W {
FBE_W { w: self }
}
#[doc = "Bit 14 - Early Receive Interrupt Enable"]
#[inline(always)]
pub fn ere(&mut self) -> ERE_W {
ERE_W { w: self }
}
#[doc = "Bit 15 - Abnormal Interrupt Summary Enable"]
#[inline(always)]
pub fn aie(&mut self) -> AIE_W {
AIE_W { w: self }
}
#[doc = "Bit 16 - Normal Interrupt Summary Enable"]
#[inline(always)]
pub fn nie(&mut self) -> NIE_W {
NIE_W { w: self }
}
}