#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
impl super::SR {
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
}
#[doc = r"Value of the field"]
pub struct CTSIZER {
bits: u16,
}
impl CTSIZER {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u16 {
self.bits
}
}
#[doc = "Possible values of the field `RXWNE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RXWNER {
#[doc = "Less than 32-bit data frame received"]
LESSTHAN32,
#[doc = "At least 32-bit data frame received"]
ATLEAST32,
}
impl RXWNER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
RXWNER::LESSTHAN32 => false,
RXWNER::ATLEAST32 => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> RXWNER {
match value {
false => RXWNER::LESSTHAN32,
true => RXWNER::ATLEAST32,
}
}
#[doc = "Checks if the value of the field is `LESSTHAN32`"]
#[inline(always)]
pub fn is_less_than32(&self) -> bool {
*self == RXWNER::LESSTHAN32
}
#[doc = "Checks if the value of the field is `ATLEAST32`"]
#[inline(always)]
pub fn is_at_least32(&self) -> bool {
*self == RXWNER::ATLEAST32
}
}
#[doc = "Possible values of the field `RXPLVL`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RXPLVLR {
#[doc = "Zero frames beyond packing ratio available"]
ZEROFRAMES,
#[doc = "One frame beyond packing ratio available"]
ONEFRAME,
#[doc = "Two frame beyond packing ratio available"]
TWOFRAMES,
#[doc = "Three frame beyond packing ratio available"]
THREEFRAMES,
}
impl RXPLVLR {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u8 {
match *self {
RXPLVLR::ZEROFRAMES => 0,
RXPLVLR::ONEFRAME => 0x01,
RXPLVLR::TWOFRAMES => 0x02,
RXPLVLR::THREEFRAMES => 0x03,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: u8) -> RXPLVLR {
match value {
0 => RXPLVLR::ZEROFRAMES,
1 => RXPLVLR::ONEFRAME,
2 => RXPLVLR::TWOFRAMES,
3 => RXPLVLR::THREEFRAMES,
_ => unreachable!(),
}
}
#[doc = "Checks if the value of the field is `ZEROFRAMES`"]
#[inline(always)]
pub fn is_zero_frames(&self) -> bool {
*self == RXPLVLR::ZEROFRAMES
}
#[doc = "Checks if the value of the field is `ONEFRAME`"]
#[inline(always)]
pub fn is_one_frame(&self) -> bool {
*self == RXPLVLR::ONEFRAME
}
#[doc = "Checks if the value of the field is `TWOFRAMES`"]
#[inline(always)]
pub fn is_two_frames(&self) -> bool {
*self == RXPLVLR::TWOFRAMES
}
#[doc = "Checks if the value of the field is `THREEFRAMES`"]
#[inline(always)]
pub fn is_three_frames(&self) -> bool {
*self == RXPLVLR::THREEFRAMES
}
}
#[doc = "Possible values of the field `TXC`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TXCR {
#[doc = "Transmission ongoing"]
ONGOING,
#[doc = "Transmission completed"]
COMPLETED,
}
impl TXCR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TXCR::ONGOING => false,
TXCR::COMPLETED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TXCR {
match value {
false => TXCR::ONGOING,
true => TXCR::COMPLETED,
}
}
#[doc = "Checks if the value of the field is `ONGOING`"]
#[inline(always)]
pub fn is_ongoing(&self) -> bool {
*self == TXCR::ONGOING
}
#[doc = "Checks if the value of the field is `COMPLETED`"]
#[inline(always)]
pub fn is_completed(&self) -> bool {
*self == TXCR::COMPLETED
}
}
#[doc = "Possible values of the field `SUSP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SUSPR {
#[doc = "Master not suspended"]
NOTSUSPENDED,
#[doc = "Master suspended"]
SUSPENDED,
}
impl SUSPR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
SUSPR::NOTSUSPENDED => false,
SUSPR::SUSPENDED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> SUSPR {
match value {
false => SUSPR::NOTSUSPENDED,
true => SUSPR::SUSPENDED,
}
}
#[doc = "Checks if the value of the field is `NOTSUSPENDED`"]
#[inline(always)]
pub fn is_not_suspended(&self) -> bool {
*self == SUSPR::NOTSUSPENDED
}
#[doc = "Checks if the value of the field is `SUSPENDED`"]
#[inline(always)]
pub fn is_suspended(&self) -> bool {
*self == SUSPR::SUSPENDED
}
}
#[doc = "Possible values of the field `TSERF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TSERFR {
#[doc = "Additional number of SPI data to be transacted not yet loaded"]
NOTLOADED,
#[doc = "Additional number of SPI data to be transacted was reloaded"]
LOADED,
}
impl TSERFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TSERFR::NOTLOADED => false,
TSERFR::LOADED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TSERFR {
match value {
false => TSERFR::NOTLOADED,
true => TSERFR::LOADED,
}
}
#[doc = "Checks if the value of the field is `NOTLOADED`"]
#[inline(always)]
pub fn is_not_loaded(&self) -> bool {
*self == TSERFR::NOTLOADED
}
#[doc = "Checks if the value of the field is `LOADED`"]
#[inline(always)]
pub fn is_loaded(&self) -> bool {
*self == TSERFR::LOADED
}
}
#[doc = "Possible values of the field `MODF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MODFR {
#[doc = "No mode fault detected"]
NOFAULT,
#[doc = "Mode fault detected"]
FAULT,
}
impl MODFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
MODFR::NOFAULT => false,
MODFR::FAULT => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> MODFR {
match value {
false => MODFR::NOFAULT,
true => MODFR::FAULT,
}
}
#[doc = "Checks if the value of the field is `NOFAULT`"]
#[inline(always)]
pub fn is_no_fault(&self) -> bool {
*self == MODFR::NOFAULT
}
#[doc = "Checks if the value of the field is `FAULT`"]
#[inline(always)]
pub fn is_fault(&self) -> bool {
*self == MODFR::FAULT
}
}
#[doc = "Possible values of the field `TIFRE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TIFRER {
#[doc = "TI frame format error detected"]
NOERROR,
#[doc = "TI frame format error detected"]
ERROR,
}
impl TIFRER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TIFRER::NOERROR => false,
TIFRER::ERROR => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TIFRER {
match value {
false => TIFRER::NOERROR,
true => TIFRER::ERROR,
}
}
#[doc = "Checks if the value of the field is `NOERROR`"]
#[inline(always)]
pub fn is_no_error(&self) -> bool {
*self == TIFRER::NOERROR
}
#[doc = "Checks if the value of the field is `ERROR`"]
#[inline(always)]
pub fn is_error(&self) -> bool {
*self == TIFRER::ERROR
}
}
#[doc = "Possible values of the field `CRCE`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum CRCER {
#[doc = "No CRC error detected"]
NOERROR,
#[doc = "CRC error detected"]
ERROR,
}
impl CRCER {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
CRCER::NOERROR => false,
CRCER::ERROR => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> CRCER {
match value {
false => CRCER::NOERROR,
true => CRCER::ERROR,
}
}
#[doc = "Checks if the value of the field is `NOERROR`"]
#[inline(always)]
pub fn is_no_error(&self) -> bool {
*self == CRCER::NOERROR
}
#[doc = "Checks if the value of the field is `ERROR`"]
#[inline(always)]
pub fn is_error(&self) -> bool {
*self == CRCER::ERROR
}
}
#[doc = "Possible values of the field `OVR`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum OVRR {
#[doc = "No overrun occurred"]
NOOVERRUN,
#[doc = "Overrun occurred"]
OVERRUN,
}
impl OVRR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
OVRR::NOOVERRUN => false,
OVRR::OVERRUN => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> OVRR {
match value {
false => OVRR::NOOVERRUN,
true => OVRR::OVERRUN,
}
}
#[doc = "Checks if the value of the field is `NOOVERRUN`"]
#[inline(always)]
pub fn is_no_overrun(&self) -> bool {
*self == OVRR::NOOVERRUN
}
#[doc = "Checks if the value of the field is `OVERRUN`"]
#[inline(always)]
pub fn is_overrun(&self) -> bool {
*self == OVRR::OVERRUN
}
}
#[doc = "Possible values of the field `UDR`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UDRR {
#[doc = "No underrun occurred"]
NOUNDERRUN,
#[doc = "Underrun occurred"]
UNDERRUN,
}
impl UDRR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
UDRR::NOUNDERRUN => false,
UDRR::UNDERRUN => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> UDRR {
match value {
false => UDRR::NOUNDERRUN,
true => UDRR::UNDERRUN,
}
}
#[doc = "Checks if the value of the field is `NOUNDERRUN`"]
#[inline(always)]
pub fn is_no_underrun(&self) -> bool {
*self == UDRR::NOUNDERRUN
}
#[doc = "Checks if the value of the field is `UNDERRUN`"]
#[inline(always)]
pub fn is_underrun(&self) -> bool {
*self == UDRR::UNDERRUN
}
}
#[doc = "Possible values of the field `TXTF`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TXTFR {
#[doc = "Transmission buffer incomplete"]
NOTCOMPLETED,
#[doc = "Transmission buffer filled with at least one transfer"]
COMPLETED,
}
impl TXTFR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TXTFR::NOTCOMPLETED => false,
TXTFR::COMPLETED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TXTFR {
match value {
false => TXTFR::NOTCOMPLETED,
true => TXTFR::COMPLETED,
}
}
#[doc = "Checks if the value of the field is `NOTCOMPLETED`"]
#[inline(always)]
pub fn is_not_completed(&self) -> bool {
*self == TXTFR::NOTCOMPLETED
}
#[doc = "Checks if the value of the field is `COMPLETED`"]
#[inline(always)]
pub fn is_completed(&self) -> bool {
*self == TXTFR::COMPLETED
}
}
#[doc = "Possible values of the field `EOT`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EOTR {
#[doc = "Transfer ongoing or not started"]
NOTCOMPLETED,
#[doc = "Transfer complete"]
COMPLETED,
}
impl EOTR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
EOTR::NOTCOMPLETED => false,
EOTR::COMPLETED => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> EOTR {
match value {
false => EOTR::NOTCOMPLETED,
true => EOTR::COMPLETED,
}
}
#[doc = "Checks if the value of the field is `NOTCOMPLETED`"]
#[inline(always)]
pub fn is_not_completed(&self) -> bool {
*self == EOTR::NOTCOMPLETED
}
#[doc = "Checks if the value of the field is `COMPLETED`"]
#[inline(always)]
pub fn is_completed(&self) -> bool {
*self == EOTR::COMPLETED
}
}
#[doc = "Possible values of the field `DXP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum DXPR {
#[doc = "Duplex packet unavailable: no space for transmission and/or no data received"]
UNAVAILABLE,
#[doc = "Duplex packet available: space for transmission and data received"]
AVAILABLE,
}
impl DXPR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
DXPR::UNAVAILABLE => false,
DXPR::AVAILABLE => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> DXPR {
match value {
false => DXPR::UNAVAILABLE,
true => DXPR::AVAILABLE,
}
}
#[doc = "Checks if the value of the field is `UNAVAILABLE`"]
#[inline(always)]
pub fn is_unavailable(&self) -> bool {
*self == DXPR::UNAVAILABLE
}
#[doc = "Checks if the value of the field is `AVAILABLE`"]
#[inline(always)]
pub fn is_available(&self) -> bool {
*self == DXPR::AVAILABLE
}
}
#[doc = "Possible values of the field `TXP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TXPR {
#[doc = "Tx buffer full"]
FULL,
#[doc = "Tx buffer not full"]
NOTFULL,
}
impl TXPR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
TXPR::FULL => false,
TXPR::NOTFULL => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> TXPR {
match value {
false => TXPR::FULL,
true => TXPR::NOTFULL,
}
}
#[doc = "Checks if the value of the field is `FULL`"]
#[inline(always)]
pub fn is_full(&self) -> bool {
*self == TXPR::FULL
}
#[doc = "Checks if the value of the field is `NOTFULL`"]
#[inline(always)]
pub fn is_not_full(&self) -> bool {
*self == TXPR::NOTFULL
}
}
#[doc = "Possible values of the field `RXP`"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RXPR {
#[doc = "Rx buffer empty"]
EMPTY,
#[doc = "Rx buffer not empty"]
NOTEMPTY,
}
impl RXPR {
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
match *self {
RXPR::EMPTY => false,
RXPR::NOTEMPTY => true,
}
}
#[allow(missing_docs)]
#[doc(hidden)]
#[inline(always)]
pub fn _from(value: bool) -> RXPR {
match value {
false => RXPR::EMPTY,
true => RXPR::NOTEMPTY,
}
}
#[doc = "Checks if the value of the field is `EMPTY`"]
#[inline(always)]
pub fn is_empty(&self) -> bool {
*self == RXPR::EMPTY
}
#[doc = "Checks if the value of the field is `NOTEMPTY`"]
#[inline(always)]
pub fn is_not_empty(&self) -> bool {
*self == RXPR::NOTEMPTY
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bits 16:31 - Number of data frames remaining in current TSIZE session"]
#[inline(always)]
pub fn ctsize(&self) -> CTSIZER {
let bits = ((self.bits >> 16) & 0xffff) as u16;
CTSIZER { bits }
}
#[doc = "Bit 15 - RxFIFO Word Not Empty"]
#[inline(always)]
pub fn rxwne(&self) -> RXWNER {
RXWNER::_from(((self.bits >> 15) & 0x01) != 0)
}
#[doc = "Bits 13:14 - RxFIFO Packing LeVeL"]
#[inline(always)]
pub fn rxplvl(&self) -> RXPLVLR {
RXPLVLR::_from(((self.bits >> 13) & 0x03) as u8)
}
#[doc = "Bit 12 - TxFIFO transmission complete"]
#[inline(always)]
pub fn txc(&self) -> TXCR {
TXCR::_from(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 11 - SUSPend"]
#[inline(always)]
pub fn susp(&self) -> SUSPR {
SUSPR::_from(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 10 - Additional number of SPI data to be transacted was reload"]
#[inline(always)]
pub fn tserf(&self) -> TSERFR {
TSERFR::_from(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 9 - Mode Fault"]
#[inline(always)]
pub fn modf(&self) -> MODFR {
MODFR::_from(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 8 - TI frame format error"]
#[inline(always)]
pub fn tifre(&self) -> TIFRER {
TIFRER::_from(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 7 - CRC Error"]
#[inline(always)]
pub fn crce(&self) -> CRCER {
CRCER::_from(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 6 - Overrun"]
#[inline(always)]
pub fn ovr(&self) -> OVRR {
OVRR::_from(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 5 - Underrun at slave transmission mode"]
#[inline(always)]
pub fn udr(&self) -> UDRR {
UDRR::_from(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 4 - Transmission Transfer Filled"]
#[inline(always)]
pub fn txtf(&self) -> TXTFR {
TXTFR::_from(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 3 - End Of Transfer"]
#[inline(always)]
pub fn eot(&self) -> EOTR {
EOTR::_from(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 2 - Duplex Packet"]
#[inline(always)]
pub fn dxp(&self) -> DXPR {
DXPR::_from(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 1 - Tx-Packet space available"]
#[inline(always)]
pub fn txp(&self) -> TXPR {
TXPR::_from(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 0 - Rx-Packet available"]
#[inline(always)]
pub fn rxp(&self) -> RXPR {
RXPR::_from(((self.bits >> 0) & 0x01) != 0)
}
}