#[doc = "Alignment Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ale(pub u32);
impl Ale {
#[doc = "Alignment Errors"]
#[must_use]
#[inline(always)]
pub const fn ale(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Alignment Errors"]
#[inline(always)]
pub const fn set_ale(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ale {
#[inline(always)]
fn default() -> Ale {
Ale(0)
}
}
impl core::fmt::Debug for Ale {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ale").field("ale", &self.ale()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ale {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ale {{ ale: {=u8:?} }}", self.ale())
}
}
#[doc = "Carrier Sense Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cse(pub u32);
impl Cse {
#[doc = "Carrier Sense Errors"]
#[must_use]
#[inline(always)]
pub const fn cse(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Carrier Sense Errors"]
#[inline(always)]
pub const fn set_cse(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Cse {
#[inline(always)]
fn default() -> Cse {
Cse(0)
}
}
impl core::fmt::Debug for Cse {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cse").field("cse", &self.cse()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cse {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Cse {{ cse: {=u8:?} }}", self.cse())
}
}
#[doc = "Deferred Transmission Frames Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dtf(pub u32);
impl Dtf {
#[doc = "Deferred Transmission Frames"]
#[must_use]
#[inline(always)]
pub const fn dtf(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Deferred Transmission Frames"]
#[inline(always)]
pub const fn set_dtf(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Dtf {
#[inline(always)]
fn default() -> Dtf {
Dtf(0)
}
}
impl core::fmt::Debug for Dtf {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dtf").field("dtf", &self.dtf()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dtf {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dtf {{ dtf: {=u16:?} }}", self.dtf())
}
}
#[doc = "Excessive Collisions Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ecol(pub u32);
impl Ecol {
#[doc = "Excessive Collisions"]
#[must_use]
#[inline(always)]
pub const fn excol(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Excessive Collisions"]
#[inline(always)]
pub const fn set_excol(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ecol {
#[inline(always)]
fn default() -> Ecol {
Ecol(0)
}
}
impl core::fmt::Debug for Ecol {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ecol")
.field("excol", &self.excol())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ecol {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ecol {{ excol: {=u8:?} }}", self.excol())
}
}
#[doc = "Excessive Length Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ele(pub u32);
impl Ele {
#[doc = "Excessive Length Errors"]
#[must_use]
#[inline(always)]
pub const fn exl(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Excessive Length Errors"]
#[inline(always)]
pub const fn set_exl(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ele {
#[inline(always)]
fn default() -> Ele {
Ele(0)
}
}
impl core::fmt::Debug for Ele {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ele").field("exl", &self.exl()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ele {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ele {{ exl: {=u8:?} }}", self.exl())
}
}
#[doc = "Frame Check Sequence Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fcse(pub u32);
impl Fcse {
#[doc = "Frame Check Sequence Errors"]
#[must_use]
#[inline(always)]
pub const fn fcse(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Frame Check Sequence Errors"]
#[inline(always)]
pub const fn set_fcse(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Fcse {
#[inline(always)]
fn default() -> Fcse {
Fcse(0)
}
}
impl core::fmt::Debug for Fcse {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fcse").field("fcse", &self.fcse()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fcse {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Fcse {{ fcse: {=u8:?} }}", self.fcse())
}
}
#[doc = "Frames Received Ok Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fro(pub u32);
impl Fro {
#[doc = "Frames Received OK"]
#[must_use]
#[inline(always)]
pub const fn frok(&self) -> u32 {
let val = (self.0 >> 0usize) & 0x00ff_ffff;
val as u32
}
#[doc = "Frames Received OK"]
#[inline(always)]
pub const fn set_frok(&mut self, val: u32) {
self.0 = (self.0 & !(0x00ff_ffff << 0usize)) | (((val as u32) & 0x00ff_ffff) << 0usize);
}
}
impl Default for Fro {
#[inline(always)]
fn default() -> Fro {
Fro(0)
}
}
impl core::fmt::Debug for Fro {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fro").field("frok", &self.frok()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fro {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Fro {{ frok: {=u32:?} }}", self.frok())
}
}
#[doc = "Frames Transmitted Ok Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Fto(pub u32);
impl Fto {
#[doc = "Frames Transmitted OK"]
#[must_use]
#[inline(always)]
pub const fn ftok(&self) -> u32 {
let val = (self.0 >> 0usize) & 0x00ff_ffff;
val as u32
}
#[doc = "Frames Transmitted OK"]
#[inline(always)]
pub const fn set_ftok(&mut self, val: u32) {
self.0 = (self.0 & !(0x00ff_ffff << 0usize)) | (((val as u32) & 0x00ff_ffff) << 0usize);
}
}
impl Default for Fto {
#[inline(always)]
fn default() -> Fto {
Fto(0)
}
}
impl core::fmt::Debug for Fto {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Fto").field("ftok", &self.ftok()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Fto {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Fto {{ ftok: {=u32:?} }}", self.ftok())
}
}
#[doc = "Hash Register Bottom \\[31:0\\] Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Hrb(pub u32);
impl Hrb {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Hrb {
#[inline(always)]
fn default() -> Hrb {
Hrb(0)
}
}
impl core::fmt::Debug for Hrb {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Hrb").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Hrb {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Hrb {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Hash Register Top \\[63:32\\] Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Hrt(pub u32);
impl Hrt {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Hrt {
#[inline(always)]
fn default() -> Hrt {
Hrt(0)
}
}
impl core::fmt::Debug for Hrt {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Hrt").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Hrt {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Hrt {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Interrupt Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Idr(pub u32);
impl Idr {
#[doc = "Management Frame sent"]
#[must_use]
#[inline(always)]
pub const fn mfd(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Management Frame sent"]
#[inline(always)]
pub const fn set_mfd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receive Complete"]
#[must_use]
#[inline(always)]
pub const fn rcomp(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receive Complete"]
#[inline(always)]
pub const fn set_rcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn rxubr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive Used Bit Read"]
#[inline(always)]
pub const fn set_rxubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn txubr(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Used Bit Read"]
#[inline(always)]
pub const fn set_txubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[must_use]
#[inline(always)]
pub const fn tund(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[inline(always)]
pub const fn set_tund(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Retry Limit Exceeded"]
#[must_use]
#[inline(always)]
pub const fn rle(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Retry Limit Exceeded"]
#[inline(always)]
pub const fn set_rle(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[must_use]
#[inline(always)]
pub const fn txerr(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_txerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Transmit Complete"]
#[must_use]
#[inline(always)]
pub const fn tcomp(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Transmit Complete"]
#[inline(always)]
pub const fn set_tcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn rovr(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_rovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Hresp not OK"]
#[must_use]
#[inline(always)]
pub const fn hresp(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Hresp not OK"]
#[inline(always)]
pub const fn set_hresp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Pause Frame Received"]
#[must_use]
#[inline(always)]
pub const fn pfr(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Pause Frame Received"]
#[inline(always)]
pub const fn set_pfr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Pause Time Zero"]
#[must_use]
#[inline(always)]
pub const fn ptz(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Pause Time Zero"]
#[inline(always)]
pub const fn set_ptz(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
}
impl Default for Idr {
#[inline(always)]
fn default() -> Idr {
Idr(0)
}
}
impl core::fmt::Debug for Idr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Idr")
.field("mfd", &self.mfd())
.field("rcomp", &self.rcomp())
.field("rxubr", &self.rxubr())
.field("txubr", &self.txubr())
.field("tund", &self.tund())
.field("rle", &self.rle())
.field("txerr", &self.txerr())
.field("tcomp", &self.tcomp())
.field("rovr", &self.rovr())
.field("hresp", &self.hresp())
.field("pfr", &self.pfr())
.field("ptz", &self.ptz())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Idr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Idr {{ mfd: {=bool:?}, rcomp: {=bool:?}, rxubr: {=bool:?}, txubr: {=bool:?}, tund: {=bool:?}, rle: {=bool:?}, txerr: {=bool:?}, tcomp: {=bool:?}, rovr: {=bool:?}, hresp: {=bool:?}, pfr: {=bool:?}, ptz: {=bool:?} }}",
self.mfd(),
self.rcomp(),
self.rxubr(),
self.txubr(),
self.tund(),
self.rle(),
self.txerr(),
self.tcomp(),
self.rovr(),
self.hresp(),
self.pfr(),
self.ptz()
)
}
}
#[doc = "Interrupt Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ier(pub u32);
impl Ier {
#[doc = "Management Frame sent"]
#[must_use]
#[inline(always)]
pub const fn mfd(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Management Frame sent"]
#[inline(always)]
pub const fn set_mfd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receive Complete"]
#[must_use]
#[inline(always)]
pub const fn rcomp(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receive Complete"]
#[inline(always)]
pub const fn set_rcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn rxubr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive Used Bit Read"]
#[inline(always)]
pub const fn set_rxubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn txubr(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Used Bit Read"]
#[inline(always)]
pub const fn set_txubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[must_use]
#[inline(always)]
pub const fn tund(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[inline(always)]
pub const fn set_tund(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Retry Limit Exceeded"]
#[must_use]
#[inline(always)]
pub const fn rle(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Retry Limit Exceeded"]
#[inline(always)]
pub const fn set_rle(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[must_use]
#[inline(always)]
pub const fn txerr(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_txerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Transmit Complete"]
#[must_use]
#[inline(always)]
pub const fn tcomp(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Transmit Complete"]
#[inline(always)]
pub const fn set_tcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn rovr(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_rovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Hresp not OK"]
#[must_use]
#[inline(always)]
pub const fn hresp(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Hresp not OK"]
#[inline(always)]
pub const fn set_hresp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Pause Frame Received"]
#[must_use]
#[inline(always)]
pub const fn pfr(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Pause Frame Received"]
#[inline(always)]
pub const fn set_pfr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Pause Time Zero"]
#[must_use]
#[inline(always)]
pub const fn ptz(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Pause Time Zero"]
#[inline(always)]
pub const fn set_ptz(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
}
impl Default for Ier {
#[inline(always)]
fn default() -> Ier {
Ier(0)
}
}
impl core::fmt::Debug for Ier {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ier")
.field("mfd", &self.mfd())
.field("rcomp", &self.rcomp())
.field("rxubr", &self.rxubr())
.field("txubr", &self.txubr())
.field("tund", &self.tund())
.field("rle", &self.rle())
.field("txerr", &self.txerr())
.field("tcomp", &self.tcomp())
.field("rovr", &self.rovr())
.field("hresp", &self.hresp())
.field("pfr", &self.pfr())
.field("ptz", &self.ptz())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ier {{ mfd: {=bool:?}, rcomp: {=bool:?}, rxubr: {=bool:?}, txubr: {=bool:?}, tund: {=bool:?}, rle: {=bool:?}, txerr: {=bool:?}, tcomp: {=bool:?}, rovr: {=bool:?}, hresp: {=bool:?}, pfr: {=bool:?}, ptz: {=bool:?} }}",
self.mfd(),
self.rcomp(),
self.rxubr(),
self.txubr(),
self.tund(),
self.rle(),
self.txerr(),
self.tcomp(),
self.rovr(),
self.hresp(),
self.pfr(),
self.ptz()
)
}
}
#[doc = "Interrupt Mask Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Imr(pub u32);
impl Imr {
#[doc = "Management Frame sent"]
#[must_use]
#[inline(always)]
pub const fn mfd(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Management Frame sent"]
#[inline(always)]
pub const fn set_mfd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receive Complete"]
#[must_use]
#[inline(always)]
pub const fn rcomp(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receive Complete"]
#[inline(always)]
pub const fn set_rcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn rxubr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive Used Bit Read"]
#[inline(always)]
pub const fn set_rxubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn txubr(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Used Bit Read"]
#[inline(always)]
pub const fn set_txubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[must_use]
#[inline(always)]
pub const fn tund(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[inline(always)]
pub const fn set_tund(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Retry Limit Exceeded"]
#[must_use]
#[inline(always)]
pub const fn rle(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Retry Limit Exceeded"]
#[inline(always)]
pub const fn set_rle(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[must_use]
#[inline(always)]
pub const fn txerr(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_txerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Transmit Complete"]
#[must_use]
#[inline(always)]
pub const fn tcomp(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Transmit Complete"]
#[inline(always)]
pub const fn set_tcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn rovr(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_rovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Hresp not OK"]
#[must_use]
#[inline(always)]
pub const fn hresp(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Hresp not OK"]
#[inline(always)]
pub const fn set_hresp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Pause Frame Received"]
#[must_use]
#[inline(always)]
pub const fn pfr(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Pause Frame Received"]
#[inline(always)]
pub const fn set_pfr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Pause Time Zero"]
#[must_use]
#[inline(always)]
pub const fn ptz(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Pause Time Zero"]
#[inline(always)]
pub const fn set_ptz(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
}
impl Default for Imr {
#[inline(always)]
fn default() -> Imr {
Imr(0)
}
}
impl core::fmt::Debug for Imr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Imr")
.field("mfd", &self.mfd())
.field("rcomp", &self.rcomp())
.field("rxubr", &self.rxubr())
.field("txubr", &self.txubr())
.field("tund", &self.tund())
.field("rle", &self.rle())
.field("txerr", &self.txerr())
.field("tcomp", &self.tcomp())
.field("rovr", &self.rovr())
.field("hresp", &self.hresp())
.field("pfr", &self.pfr())
.field("ptz", &self.ptz())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Imr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Imr {{ mfd: {=bool:?}, rcomp: {=bool:?}, rxubr: {=bool:?}, txubr: {=bool:?}, tund: {=bool:?}, rle: {=bool:?}, txerr: {=bool:?}, tcomp: {=bool:?}, rovr: {=bool:?}, hresp: {=bool:?}, pfr: {=bool:?}, ptz: {=bool:?} }}",
self.mfd(),
self.rcomp(),
self.rxubr(),
self.txubr(),
self.tund(),
self.rle(),
self.txerr(),
self.tcomp(),
self.rovr(),
self.hresp(),
self.pfr(),
self.ptz()
)
}
}
#[doc = "Interrupt Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Isr(pub u32);
impl Isr {
#[doc = "Management Frame Done"]
#[must_use]
#[inline(always)]
pub const fn mfd(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Management Frame Done"]
#[inline(always)]
pub const fn set_mfd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Receive Complete"]
#[must_use]
#[inline(always)]
pub const fn rcomp(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Receive Complete"]
#[inline(always)]
pub const fn set_rcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn rxubr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive Used Bit Read"]
#[inline(always)]
pub const fn set_rxubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn txubr(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Used Bit Read"]
#[inline(always)]
pub const fn set_txubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[must_use]
#[inline(always)]
pub const fn tund(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Ethernet Transmit Buffer Underrun"]
#[inline(always)]
pub const fn set_tund(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Retry Limit Exceeded"]
#[must_use]
#[inline(always)]
pub const fn rlex(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Retry Limit Exceeded"]
#[inline(always)]
pub const fn set_rlex(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Transmit Error"]
#[must_use]
#[inline(always)]
pub const fn txerr(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Transmit Error"]
#[inline(always)]
pub const fn set_txerr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Transmit Complete"]
#[must_use]
#[inline(always)]
pub const fn tcomp(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Transmit Complete"]
#[inline(always)]
pub const fn set_tcomp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn rovr(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_rovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Hresp not OK"]
#[must_use]
#[inline(always)]
pub const fn hresp(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Hresp not OK"]
#[inline(always)]
pub const fn set_hresp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Pause Frame Received"]
#[must_use]
#[inline(always)]
pub const fn pfre(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Pause Frame Received"]
#[inline(always)]
pub const fn set_pfre(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Pause Time Zero"]
#[must_use]
#[inline(always)]
pub const fn ptz(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Pause Time Zero"]
#[inline(always)]
pub const fn set_ptz(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
}
impl Default for Isr {
#[inline(always)]
fn default() -> Isr {
Isr(0)
}
}
impl core::fmt::Debug for Isr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Isr")
.field("mfd", &self.mfd())
.field("rcomp", &self.rcomp())
.field("rxubr", &self.rxubr())
.field("txubr", &self.txubr())
.field("tund", &self.tund())
.field("rlex", &self.rlex())
.field("txerr", &self.txerr())
.field("tcomp", &self.tcomp())
.field("rovr", &self.rovr())
.field("hresp", &self.hresp())
.field("pfre", &self.pfre())
.field("ptz", &self.ptz())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Isr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Isr {{ mfd: {=bool:?}, rcomp: {=bool:?}, rxubr: {=bool:?}, txubr: {=bool:?}, tund: {=bool:?}, rlex: {=bool:?}, txerr: {=bool:?}, tcomp: {=bool:?}, rovr: {=bool:?}, hresp: {=bool:?}, pfre: {=bool:?}, ptz: {=bool:?} }}",
self.mfd(),
self.rcomp(),
self.rxubr(),
self.txubr(),
self.tund(),
self.rlex(),
self.txerr(),
self.tcomp(),
self.rovr(),
self.hresp(),
self.pfre(),
self.ptz()
)
}
}
#[doc = "Late Collisions Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Lcol(pub u32);
impl Lcol {
#[doc = "Late Collisions"]
#[must_use]
#[inline(always)]
pub const fn lcol(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Late Collisions"]
#[inline(always)]
pub const fn set_lcol(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Lcol {
#[inline(always)]
fn default() -> Lcol {
Lcol(0)
}
}
impl core::fmt::Debug for Lcol {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Lcol").field("lcol", &self.lcol()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Lcol {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Lcol {{ lcol: {=u8:?} }}", self.lcol())
}
}
#[doc = "Phy Maintenance Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Man(pub u32);
impl Man {
#[must_use]
#[inline(always)]
pub const fn data(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[inline(always)]
pub const fn set_data(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[must_use]
#[inline(always)]
pub const fn code(&self) -> u8 {
let val = (self.0 >> 16usize) & 0x03;
val as u8
}
#[inline(always)]
pub const fn set_code(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 16usize)) | (((val as u32) & 0x03) << 16usize);
}
#[doc = "Register Address"]
#[must_use]
#[inline(always)]
pub const fn rega(&self) -> u8 {
let val = (self.0 >> 18usize) & 0x1f;
val as u8
}
#[doc = "Register Address"]
#[inline(always)]
pub const fn set_rega(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 18usize)) | (((val as u32) & 0x1f) << 18usize);
}
#[doc = "PHY Address"]
#[must_use]
#[inline(always)]
pub const fn phya(&self) -> u8 {
let val = (self.0 >> 23usize) & 0x1f;
val as u8
}
#[doc = "PHY Address"]
#[inline(always)]
pub const fn set_phya(&mut self, val: u8) {
self.0 = (self.0 & !(0x1f << 23usize)) | (((val as u32) & 0x1f) << 23usize);
}
#[doc = "Read-write"]
#[must_use]
#[inline(always)]
pub const fn rw(&self) -> u8 {
let val = (self.0 >> 28usize) & 0x03;
val as u8
}
#[doc = "Read-write"]
#[inline(always)]
pub const fn set_rw(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val as u32) & 0x03) << 28usize);
}
#[doc = "Start of frame"]
#[must_use]
#[inline(always)]
pub const fn sof(&self) -> u8 {
let val = (self.0 >> 30usize) & 0x03;
val as u8
}
#[doc = "Start of frame"]
#[inline(always)]
pub const fn set_sof(&mut self, val: u8) {
self.0 = (self.0 & !(0x03 << 30usize)) | (((val as u32) & 0x03) << 30usize);
}
}
impl Default for Man {
#[inline(always)]
fn default() -> Man {
Man(0)
}
}
impl core::fmt::Debug for Man {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Man")
.field("data", &self.data())
.field("code", &self.code())
.field("rega", &self.rega())
.field("phya", &self.phya())
.field("rw", &self.rw())
.field("sof", &self.sof())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Man {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Man {{ data: {=u16:?}, code: {=u8:?}, rega: {=u8:?}, phya: {=u8:?}, rw: {=u8:?}, sof: {=u8:?} }}",
self.data(),
self.code(),
self.rega(),
self.phya(),
self.rw(),
self.sof()
)
}
}
#[doc = "Multiple Collision Frames Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Mcf(pub u32);
impl Mcf {
#[doc = "Multicollision Frames"]
#[must_use]
#[inline(always)]
pub const fn mcf(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Multicollision Frames"]
#[inline(always)]
pub const fn set_mcf(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Mcf {
#[inline(always)]
fn default() -> Mcf {
Mcf(0)
}
}
impl core::fmt::Debug for Mcf {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Mcf").field("mcf", &self.mcf()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Mcf {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Mcf {{ mcf: {=u16:?} }}", self.mcf())
}
}
#[doc = "Network Configuration Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ncfgr(pub u32);
impl Ncfgr {
#[doc = "Speed"]
#[must_use]
#[inline(always)]
pub const fn spd(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Speed"]
#[inline(always)]
pub const fn set_spd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Full Duplex"]
#[must_use]
#[inline(always)]
pub const fn fd(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Full Duplex"]
#[inline(always)]
pub const fn set_fd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Jumbo Frames"]
#[must_use]
#[inline(always)]
pub const fn jframe(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Jumbo Frames"]
#[inline(always)]
pub const fn set_jframe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Copy All Frames"]
#[must_use]
#[inline(always)]
pub const fn caf(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Copy All Frames"]
#[inline(always)]
pub const fn set_caf(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "No Broadcast"]
#[must_use]
#[inline(always)]
pub const fn nbc(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "No Broadcast"]
#[inline(always)]
pub const fn set_nbc(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Multicast Hash Enable"]
#[must_use]
#[inline(always)]
pub const fn mti(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Multicast Hash Enable"]
#[inline(always)]
pub const fn set_mti(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Unicast Hash Enable"]
#[must_use]
#[inline(always)]
pub const fn uni(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Unicast Hash Enable"]
#[inline(always)]
pub const fn set_uni(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Receive 1536 bytes frames"]
#[must_use]
#[inline(always)]
pub const fn big(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Receive 1536 bytes frames"]
#[inline(always)]
pub const fn set_big(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "MDC clock divider"]
#[must_use]
#[inline(always)]
pub const fn clk(&self) -> super::vals::Clk {
let val = (self.0 >> 10usize) & 0x03;
super::vals::Clk::from_bits(val as u8)
}
#[doc = "MDC clock divider"]
#[inline(always)]
pub const fn set_clk(&mut self, val: super::vals::Clk) {
self.0 = (self.0 & !(0x03 << 10usize)) | (((val.to_bits() as u32) & 0x03) << 10usize);
}
#[doc = "Retry test"]
#[must_use]
#[inline(always)]
pub const fn rty(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Retry test"]
#[inline(always)]
pub const fn set_rty(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Pause Enable"]
#[must_use]
#[inline(always)]
pub const fn pae(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Pause Enable"]
#[inline(always)]
pub const fn set_pae(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Receive Buffer Offset"]
#[must_use]
#[inline(always)]
pub const fn rbof(&self) -> super::vals::Rbof {
let val = (self.0 >> 14usize) & 0x03;
super::vals::Rbof::from_bits(val as u8)
}
#[doc = "Receive Buffer Offset"]
#[inline(always)]
pub const fn set_rbof(&mut self, val: super::vals::Rbof) {
self.0 = (self.0 & !(0x03 << 14usize)) | (((val.to_bits() as u32) & 0x03) << 14usize);
}
#[doc = "Receive Length field Checking Enable"]
#[must_use]
#[inline(always)]
pub const fn rlce(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Receive Length field Checking Enable"]
#[inline(always)]
pub const fn set_rlce(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Discard Receive FCS"]
#[must_use]
#[inline(always)]
pub const fn drfcs(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Discard Receive FCS"]
#[inline(always)]
pub const fn set_drfcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[must_use]
#[inline(always)]
pub const fn efrhd(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_efrhd(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Ignore RX FCS"]
#[must_use]
#[inline(always)]
pub const fn irxfcs(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Ignore RX FCS"]
#[inline(always)]
pub const fn set_irxfcs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
}
impl Default for Ncfgr {
#[inline(always)]
fn default() -> Ncfgr {
Ncfgr(0)
}
}
impl core::fmt::Debug for Ncfgr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ncfgr")
.field("spd", &self.spd())
.field("fd", &self.fd())
.field("jframe", &self.jframe())
.field("caf", &self.caf())
.field("nbc", &self.nbc())
.field("mti", &self.mti())
.field("uni", &self.uni())
.field("big", &self.big())
.field("clk", &self.clk())
.field("rty", &self.rty())
.field("pae", &self.pae())
.field("rbof", &self.rbof())
.field("rlce", &self.rlce())
.field("drfcs", &self.drfcs())
.field("efrhd", &self.efrhd())
.field("irxfcs", &self.irxfcs())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ncfgr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ncfgr {{ spd: {=bool:?}, fd: {=bool:?}, jframe: {=bool:?}, caf: {=bool:?}, nbc: {=bool:?}, mti: {=bool:?}, uni: {=bool:?}, big: {=bool:?}, clk: {:?}, rty: {=bool:?}, pae: {=bool:?}, rbof: {:?}, rlce: {=bool:?}, drfcs: {=bool:?}, efrhd: {=bool:?}, irxfcs: {=bool:?} }}",
self.spd(),
self.fd(),
self.jframe(),
self.caf(),
self.nbc(),
self.mti(),
self.uni(),
self.big(),
self.clk(),
self.rty(),
self.pae(),
self.rbof(),
self.rlce(),
self.drfcs(),
self.efrhd(),
self.irxfcs()
)
}
}
#[doc = "Network Control Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ncr(pub u32);
impl Ncr {
#[doc = "LoopBack"]
#[must_use]
#[inline(always)]
pub const fn lb(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "LoopBack"]
#[inline(always)]
pub const fn set_lb(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Loopback local"]
#[must_use]
#[inline(always)]
pub const fn llb(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Loopback local"]
#[inline(always)]
pub const fn set_llb(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive enable"]
#[must_use]
#[inline(always)]
pub const fn re(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive enable"]
#[inline(always)]
pub const fn set_re(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit enable"]
#[must_use]
#[inline(always)]
pub const fn te(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit enable"]
#[inline(always)]
pub const fn set_te(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Management port enable"]
#[must_use]
#[inline(always)]
pub const fn mpe(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Management port enable"]
#[inline(always)]
pub const fn set_mpe(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Clear statistics registers"]
#[must_use]
#[inline(always)]
pub const fn clrstat(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Clear statistics registers"]
#[inline(always)]
pub const fn set_clrstat(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Increment statistics registers"]
#[must_use]
#[inline(always)]
pub const fn incstat(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Increment statistics registers"]
#[inline(always)]
pub const fn set_incstat(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Write enable for statistics registers"]
#[must_use]
#[inline(always)]
pub const fn westat(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Write enable for statistics registers"]
#[inline(always)]
pub const fn set_westat(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Back pressure"]
#[must_use]
#[inline(always)]
pub const fn bp(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Back pressure"]
#[inline(always)]
pub const fn set_bp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Start transmission"]
#[must_use]
#[inline(always)]
pub const fn tstart(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Start transmission"]
#[inline(always)]
pub const fn set_tstart(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Transmit halt"]
#[must_use]
#[inline(always)]
pub const fn thalt(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Transmit halt"]
#[inline(always)]
pub const fn set_thalt(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
}
impl Default for Ncr {
#[inline(always)]
fn default() -> Ncr {
Ncr(0)
}
}
impl core::fmt::Debug for Ncr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ncr")
.field("lb", &self.lb())
.field("llb", &self.llb())
.field("re", &self.re())
.field("te", &self.te())
.field("mpe", &self.mpe())
.field("clrstat", &self.clrstat())
.field("incstat", &self.incstat())
.field("westat", &self.westat())
.field("bp", &self.bp())
.field("tstart", &self.tstart())
.field("thalt", &self.thalt())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ncr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ncr {{ lb: {=bool:?}, llb: {=bool:?}, re: {=bool:?}, te: {=bool:?}, mpe: {=bool:?}, clrstat: {=bool:?}, incstat: {=bool:?}, westat: {=bool:?}, bp: {=bool:?}, tstart: {=bool:?}, thalt: {=bool:?} }}",
self.lb(),
self.llb(),
self.re(),
self.te(),
self.mpe(),
self.clrstat(),
self.incstat(),
self.westat(),
self.bp(),
self.tstart(),
self.thalt()
)
}
}
#[doc = "Network Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Nsr(pub u32);
impl Nsr {
#[must_use]
#[inline(always)]
pub const fn mdio(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_mdio(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[must_use]
#[inline(always)]
pub const fn idle(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[inline(always)]
pub const fn set_idle(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Nsr {
#[inline(always)]
fn default() -> Nsr {
Nsr(0)
}
}
impl core::fmt::Debug for Nsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Nsr")
.field("mdio", &self.mdio())
.field("idle", &self.idle())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Nsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Nsr {{ mdio: {=bool:?}, idle: {=bool:?} }}",
self.mdio(),
self.idle()
)
}
}
#[doc = "Pause Frames Received Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Pfr(pub u32);
impl Pfr {
#[doc = "Pause Frames received OK"]
#[must_use]
#[inline(always)]
pub const fn frok(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Pause Frames received OK"]
#[inline(always)]
pub const fn set_frok(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Pfr {
#[inline(always)]
fn default() -> Pfr {
Pfr(0)
}
}
impl core::fmt::Debug for Pfr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Pfr").field("frok", &self.frok()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Pfr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Pfr {{ frok: {=u16:?} }}", self.frok())
}
}
#[doc = "Pause Time Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ptr(pub u32);
impl Ptr {
#[doc = "Pause Time"]
#[must_use]
#[inline(always)]
pub const fn ptime(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Pause Time"]
#[inline(always)]
pub const fn set_ptime(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Ptr {
#[inline(always)]
fn default() -> Ptr {
Ptr(0)
}
}
impl core::fmt::Debug for Ptr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ptr").field("ptime", &self.ptime()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ptr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ptr {{ ptime: {=u16:?} }}", self.ptime())
}
}
#[doc = "Receive Buffer Queue Pointer Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rbqp(pub u32);
impl Rbqp {
#[doc = "Receive buffer queue pointer address"]
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Receive buffer queue pointer address"]
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Rbqp {
#[inline(always)]
fn default() -> Rbqp {
Rbqp(0)
}
}
impl core::fmt::Debug for Rbqp {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rbqp").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rbqp {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rbqp {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Receive Jabbers Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rja(pub u32);
impl Rja {
#[doc = "Receive Jabbers"]
#[must_use]
#[inline(always)]
pub const fn rjb(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Receive Jabbers"]
#[inline(always)]
pub const fn set_rjb(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Rja {
#[inline(always)]
fn default() -> Rja {
Rja(0)
}
}
impl core::fmt::Debug for Rja {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rja").field("rjb", &self.rjb()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rja {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rja {{ rjb: {=u8:?} }}", self.rjb())
}
}
#[doc = "Received Length Field Mismatch Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rle(pub u32);
impl Rle {
#[doc = "Receive Length Field Mismatch"]
#[must_use]
#[inline(always)]
pub const fn rlfm(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Receive Length Field Mismatch"]
#[inline(always)]
pub const fn set_rlfm(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Rle {
#[inline(always)]
fn default() -> Rle {
Rle(0)
}
}
impl core::fmt::Debug for Rle {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rle").field("rlfm", &self.rlfm()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rle {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rle {{ rlfm: {=u8:?} }}", self.rlfm())
}
}
#[doc = "Receive Overrun Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rov(pub u32);
impl Rov {
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn rovr(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_rovr(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Rov {
#[inline(always)]
fn default() -> Rov {
Rov(0)
}
}
impl core::fmt::Debug for Rov {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rov").field("rovr", &self.rovr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rov {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rov {{ rovr: {=u8:?} }}", self.rovr())
}
}
#[doc = "Receive Resource Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rre(pub u32);
impl Rre {
#[doc = "Receive Resource Errors"]
#[must_use]
#[inline(always)]
pub const fn rre(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Receive Resource Errors"]
#[inline(always)]
pub const fn set_rre(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Rre {
#[inline(always)]
fn default() -> Rre {
Rre(0)
}
}
impl core::fmt::Debug for Rre {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rre").field("rre", &self.rre()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rre {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rre {{ rre: {=u16:?} }}", self.rre())
}
}
#[doc = "Receive Symbol Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rse(pub u32);
impl Rse {
#[doc = "Receive Symbol Errors"]
#[must_use]
#[inline(always)]
pub const fn rse(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Receive Symbol Errors"]
#[inline(always)]
pub const fn set_rse(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Rse {
#[inline(always)]
fn default() -> Rse {
Rse(0)
}
}
impl core::fmt::Debug for Rse {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rse").field("rse", &self.rse()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rse {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Rse {{ rse: {=u8:?} }}", self.rse())
}
}
#[doc = "Receive Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Rsr(pub u32);
impl Rsr {
#[doc = "Buffer Not Available"]
#[must_use]
#[inline(always)]
pub const fn bna(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Buffer Not Available"]
#[inline(always)]
pub const fn set_bna(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Frame Received"]
#[must_use]
#[inline(always)]
pub const fn rec(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Frame Received"]
#[inline(always)]
pub const fn set_rec(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Receive Overrun"]
#[must_use]
#[inline(always)]
pub const fn ovr(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Receive Overrun"]
#[inline(always)]
pub const fn set_ovr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
}
impl Default for Rsr {
#[inline(always)]
fn default() -> Rsr {
Rsr(0)
}
}
impl core::fmt::Debug for Rsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Rsr")
.field("bna", &self.bna())
.field("rec", &self.rec())
.field("ovr", &self.ovr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Rsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Rsr {{ bna: {=bool:?}, rec: {=bool:?}, ovr: {=bool:?} }}",
self.bna(),
self.rec(),
self.ovr()
)
}
}
#[doc = "Specific Address 1 Bottom Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa1b(pub u32);
impl Sa1b {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Sa1b {
#[inline(always)]
fn default() -> Sa1b {
Sa1b(0)
}
}
impl core::fmt::Debug for Sa1b {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa1b").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa1b {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa1b {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Specific Address 1 Top Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa1t(pub u32);
impl Sa1t {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Sa1t {
#[inline(always)]
fn default() -> Sa1t {
Sa1t(0)
}
}
impl core::fmt::Debug for Sa1t {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa1t").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa1t {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa1t {{ addr: {=u16:?} }}", self.addr())
}
}
#[doc = "Specific Address 2 Bottom Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa2b(pub u32);
impl Sa2b {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Sa2b {
#[inline(always)]
fn default() -> Sa2b {
Sa2b(0)
}
}
impl core::fmt::Debug for Sa2b {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa2b").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa2b {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa2b {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Specific Address 2 Top Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa2t(pub u32);
impl Sa2t {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Sa2t {
#[inline(always)]
fn default() -> Sa2t {
Sa2t(0)
}
}
impl core::fmt::Debug for Sa2t {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa2t").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa2t {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa2t {{ addr: {=u16:?} }}", self.addr())
}
}
#[doc = "Specific Address 3 Bottom Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa3b(pub u32);
impl Sa3b {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Sa3b {
#[inline(always)]
fn default() -> Sa3b {
Sa3b(0)
}
}
impl core::fmt::Debug for Sa3b {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa3b").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa3b {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa3b {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Specific Address 3 Top Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa3t(pub u32);
impl Sa3t {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Sa3t {
#[inline(always)]
fn default() -> Sa3t {
Sa3t(0)
}
}
impl core::fmt::Debug for Sa3t {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa3t").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa3t {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa3t {{ addr: {=u16:?} }}", self.addr())
}
}
#[doc = "Specific Address 4 Bottom Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa4b(pub u32);
impl Sa4b {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Sa4b {
#[inline(always)]
fn default() -> Sa4b {
Sa4b(0)
}
}
impl core::fmt::Debug for Sa4b {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa4b").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa4b {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa4b {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Specific Address 4 Top Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sa4t(pub u32);
impl Sa4t {
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[inline(always)]
pub const fn set_addr(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Sa4t {
#[inline(always)]
fn default() -> Sa4t {
Sa4t(0)
}
}
impl core::fmt::Debug for Sa4t {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sa4t").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sa4t {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Sa4t {{ addr: {=u16:?} }}", self.addr())
}
}
#[doc = "Single Collision Frames Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Scf(pub u32);
impl Scf {
#[doc = "Single Collision Frames"]
#[must_use]
#[inline(always)]
pub const fn scf(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Single Collision Frames"]
#[inline(always)]
pub const fn set_scf(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Scf {
#[inline(always)]
fn default() -> Scf {
Scf(0)
}
}
impl core::fmt::Debug for Scf {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Scf").field("scf", &self.scf()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Scf {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Scf {{ scf: {=u16:?} }}", self.scf())
}
}
#[doc = "SQE Test Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ste(pub u32);
impl Ste {
#[doc = "SQE test errors"]
#[must_use]
#[inline(always)]
pub const fn sqer(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "SQE test errors"]
#[inline(always)]
pub const fn set_sqer(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Ste {
#[inline(always)]
fn default() -> Ste {
Ste(0)
}
}
impl core::fmt::Debug for Ste {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ste").field("sqer", &self.sqer()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ste {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Ste {{ sqer: {=u8:?} }}", self.sqer())
}
}
#[doc = "Transmit Buffer Queue Pointer Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tbqp(pub u32);
impl Tbqp {
#[doc = "Transmit buffer queue pointer address"]
#[must_use]
#[inline(always)]
pub const fn addr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Transmit buffer queue pointer address"]
#[inline(always)]
pub const fn set_addr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Tbqp {
#[inline(always)]
fn default() -> Tbqp {
Tbqp(0)
}
}
impl core::fmt::Debug for Tbqp {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tbqp").field("addr", &self.addr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tbqp {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tbqp {{ addr: {=u32:?} }}", self.addr())
}
}
#[doc = "Type ID Checking Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tid(pub u32);
impl Tid {
#[doc = "Type ID checking"]
#[must_use]
#[inline(always)]
pub const fn tid(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Type ID checking"]
#[inline(always)]
pub const fn set_tid(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
}
impl Default for Tid {
#[inline(always)]
fn default() -> Tid {
Tid(0)
}
}
impl core::fmt::Debug for Tid {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tid").field("tid", &self.tid()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tid {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tid {{ tid: {=u16:?} }}", self.tid())
}
}
#[doc = "Transmit Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tsr(pub u32);
impl Tsr {
#[doc = "Used Bit Read"]
#[must_use]
#[inline(always)]
pub const fn ubr(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Used Bit Read"]
#[inline(always)]
pub const fn set_ubr(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Collision Occurred"]
#[must_use]
#[inline(always)]
pub const fn col(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Collision Occurred"]
#[inline(always)]
pub const fn set_col(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Retry Limit exceeded"]
#[must_use]
#[inline(always)]
pub const fn rles(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Retry Limit exceeded"]
#[inline(always)]
pub const fn set_rles(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Transmit Go"]
#[must_use]
#[inline(always)]
pub const fn tgo(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Transmit Go"]
#[inline(always)]
pub const fn set_tgo(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Buffers exhausted mid frame"]
#[must_use]
#[inline(always)]
pub const fn bex(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Buffers exhausted mid frame"]
#[inline(always)]
pub const fn set_bex(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Transmit Complete"]
#[must_use]
#[inline(always)]
pub const fn comp(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Transmit Complete"]
#[inline(always)]
pub const fn set_comp(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Transmit Underrun"]
#[must_use]
#[inline(always)]
pub const fn und(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Transmit Underrun"]
#[inline(always)]
pub const fn set_und(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
}
impl Default for Tsr {
#[inline(always)]
fn default() -> Tsr {
Tsr(0)
}
}
impl core::fmt::Debug for Tsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tsr")
.field("ubr", &self.ubr())
.field("col", &self.col())
.field("rles", &self.rles())
.field("tgo", &self.tgo())
.field("bex", &self.bex())
.field("comp", &self.comp())
.field("und", &self.und())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Tsr {{ ubr: {=bool:?}, col: {=bool:?}, rles: {=bool:?}, tgo: {=bool:?}, bex: {=bool:?}, comp: {=bool:?}, und: {=bool:?} }}",
self.ubr(),
self.col(),
self.rles(),
self.tgo(),
self.bex(),
self.comp(),
self.und()
)
}
}
#[doc = "Transmit Underrun Errors Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Tund(pub u32);
impl Tund {
#[doc = "Transmit Underruns"]
#[must_use]
#[inline(always)]
pub const fn tund(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Transmit Underruns"]
#[inline(always)]
pub const fn set_tund(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Tund {
#[inline(always)]
fn default() -> Tund {
Tund(0)
}
}
impl core::fmt::Debug for Tund {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Tund").field("tund", &self.tund()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Tund {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Tund {{ tund: {=u8:?} }}", self.tund())
}
}
#[doc = "Undersize Frames Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Usf(pub u32);
impl Usf {
#[doc = "Undersize frames"]
#[must_use]
#[inline(always)]
pub const fn usf(&self) -> u8 {
let val = (self.0 >> 0usize) & 0xff;
val as u8
}
#[doc = "Undersize frames"]
#[inline(always)]
pub const fn set_usf(&mut self, val: u8) {
self.0 = (self.0 & !(0xff << 0usize)) | (((val as u32) & 0xff) << 0usize);
}
}
impl Default for Usf {
#[inline(always)]
fn default() -> Usf {
Usf(0)
}
}
impl core::fmt::Debug for Usf {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Usf").field("usf", &self.usf()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Usf {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Usf {{ usf: {=u8:?} }}", self.usf())
}
}
#[doc = "User Input/Output Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Usrio(pub u32);
impl Usrio {
#[doc = "Reduce MII"]
#[must_use]
#[inline(always)]
pub const fn rmii(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Reduce MII"]
#[inline(always)]
pub const fn set_rmii(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Clock Enable"]
#[must_use]
#[inline(always)]
pub const fn clken(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Clock Enable"]
#[inline(always)]
pub const fn set_clken(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
}
impl Default for Usrio {
#[inline(always)]
fn default() -> Usrio {
Usrio(0)
}
}
impl core::fmt::Debug for Usrio {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Usrio")
.field("rmii", &self.rmii())
.field("clken", &self.clken())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Usrio {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Usrio {{ rmii: {=bool:?}, clken: {=bool:?} }}",
self.rmii(),
self.clken()
)
}
}