#[doc = "DMAC Channel Configuration Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg0(pub u32);
impl Cfg0 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg0SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg0SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg0SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg0DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg0DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg0DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg0Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg0Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg0Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg0LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg0LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg0LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg0LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg0LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg0LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg0LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg0LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg0LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg0Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg0Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg0Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg0 {
#[inline(always)]
fn default() -> Cfg0 {
Cfg0(0)
}
}
impl core::fmt::Debug for Cfg0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg0")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg0 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Configuration Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg1(pub u32);
impl Cfg1 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg1SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg1SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg1SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg1DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg1DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg1DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg1Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg1Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg1Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg1LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg1LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg1LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg1LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg1LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg1LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg1LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg1LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg1LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg1Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg1Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg1Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg1 {
#[inline(always)]
fn default() -> Cfg1 {
Cfg1(0)
}
}
impl core::fmt::Debug for Cfg1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg1")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg1 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Configuration Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg2(pub u32);
impl Cfg2 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg2SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg2SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg2SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg2DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg2DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg2DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg2Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg2Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg2Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg2LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg2LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg2LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg2LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg2LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg2LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg2LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg2LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg2LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg2Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg2Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg2Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg2 {
#[inline(always)]
fn default() -> Cfg2 {
Cfg2(0)
}
}
impl core::fmt::Debug for Cfg2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg2")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg2 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Configuration Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg3(pub u32);
impl Cfg3 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg3SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg3SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg3SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg3DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg3DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg3DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg3Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg3Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg3Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg3LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg3LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg3LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg3LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg3LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg3LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg3LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg3LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg3LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg3Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg3Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg3Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg3 {
#[inline(always)]
fn default() -> Cfg3 {
Cfg3(0)
}
}
impl core::fmt::Debug for Cfg3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg3")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg3 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Configuration Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg4(pub u32);
impl Cfg4 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg4SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg4SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg4SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg4DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg4DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg4DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg4Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg4Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg4Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg4LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg4LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg4LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg4LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg4LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg4LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg4LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg4LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg4LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg4Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg4Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg4Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg4 {
#[inline(always)]
fn default() -> Cfg4 {
Cfg4(0)
}
}
impl core::fmt::Debug for Cfg4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg4")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg4 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Configuration Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cfg5(pub u32);
impl Cfg5 {
#[doc = "Source with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn src_per(&self) -> u8 {
let val = (self.0 >> 0usize) & 0x0f;
val as u8
}
#[doc = "Source with Peripheral identifier"]
#[inline(always)]
pub const fn set_src_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 0usize)) | (((val as u32) & 0x0f) << 0usize);
}
#[doc = "Destination with Peripheral identifier"]
#[must_use]
#[inline(always)]
pub const fn dst_per(&self) -> u8 {
let val = (self.0 >> 4usize) & 0x0f;
val as u8
}
#[doc = "Destination with Peripheral identifier"]
#[inline(always)]
pub const fn set_dst_per(&mut self, val: u8) {
self.0 = (self.0 & !(0x0f << 4usize)) | (((val as u32) & 0x0f) << 4usize);
}
#[doc = "Software or Hardware Selection for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_h2sel(&self) -> super::vals::Cfg5SrcH2sel {
let val = (self.0 >> 9usize) & 0x01;
super::vals::Cfg5SrcH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Source"]
#[inline(always)]
pub const fn set_src_h2sel(&mut self, val: super::vals::Cfg5SrcH2sel) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val.to_bits() as u32) & 0x01) << 9usize);
}
#[doc = "Software or Hardware Selection for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_h2sel(&self) -> super::vals::Cfg5DstH2sel {
let val = (self.0 >> 13usize) & 0x01;
super::vals::Cfg5DstH2sel::from_bits(val as u8)
}
#[doc = "Software or Hardware Selection for the Destination"]
#[inline(always)]
pub const fn set_dst_h2sel(&mut self, val: super::vals::Cfg5DstH2sel) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val.to_bits() as u32) & 0x01) << 13usize);
}
#[doc = "Stop On Done"]
#[must_use]
#[inline(always)]
pub const fn sod(&self) -> super::vals::Cfg5Sod {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Cfg5Sod::from_bits(val as u8)
}
#[doc = "Stop On Done"]
#[inline(always)]
pub const fn set_sod(&mut self, val: super::vals::Cfg5Sod) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Interface Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if(&self) -> super::vals::Cfg5LockIf {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Cfg5LockIf::from_bits(val as u8)
}
#[doc = "Interface Lock"]
#[inline(always)]
pub const fn set_lock_if(&mut self, val: super::vals::Cfg5LockIf) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Bus Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_b(&self) -> super::vals::Cfg5LockB {
let val = (self.0 >> 21usize) & 0x01;
super::vals::Cfg5LockB::from_bits(val as u8)
}
#[doc = "Bus Lock"]
#[inline(always)]
pub const fn set_lock_b(&mut self, val: super::vals::Cfg5LockB) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val.to_bits() as u32) & 0x01) << 21usize);
}
#[doc = "Master Interface Arbiter Lock"]
#[must_use]
#[inline(always)]
pub const fn lock_if_l(&self) -> super::vals::Cfg5LockIfL {
let val = (self.0 >> 22usize) & 0x01;
super::vals::Cfg5LockIfL::from_bits(val as u8)
}
#[doc = "Master Interface Arbiter Lock"]
#[inline(always)]
pub const fn set_lock_if_l(&mut self, val: super::vals::Cfg5LockIfL) {
self.0 = (self.0 & !(0x01 << 22usize)) | (((val.to_bits() as u32) & 0x01) << 22usize);
}
#[doc = "AHB Protection"]
#[must_use]
#[inline(always)]
pub const fn ahb_prot(&self) -> u8 {
let val = (self.0 >> 24usize) & 0x07;
val as u8
}
#[doc = "AHB Protection"]
#[inline(always)]
pub const fn set_ahb_prot(&mut self, val: u8) {
self.0 = (self.0 & !(0x07 << 24usize)) | (((val as u32) & 0x07) << 24usize);
}
#[doc = "FIFO Configuration"]
#[must_use]
#[inline(always)]
pub const fn fifocfg(&self) -> super::vals::Cfg5Fifocfg {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Cfg5Fifocfg::from_bits(val as u8)
}
#[doc = "FIFO Configuration"]
#[inline(always)]
pub const fn set_fifocfg(&mut self, val: super::vals::Cfg5Fifocfg) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
}
impl Default for Cfg5 {
#[inline(always)]
fn default() -> Cfg5 {
Cfg5(0)
}
}
impl core::fmt::Debug for Cfg5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cfg5")
.field("src_per", &self.src_per())
.field("dst_per", &self.dst_per())
.field("src_h2sel", &self.src_h2sel())
.field("dst_h2sel", &self.dst_h2sel())
.field("sod", &self.sod())
.field("lock_if", &self.lock_if())
.field("lock_b", &self.lock_b())
.field("lock_if_l", &self.lock_if_l())
.field("ahb_prot", &self.ahb_prot())
.field("fifocfg", &self.fifocfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cfg5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cfg5 {{ src_per: {=u8:?}, dst_per: {=u8:?}, src_h2sel: {:?}, dst_h2sel: {:?}, sod: {:?}, lock_if: {:?}, lock_b: {:?}, lock_if_l: {:?}, ahb_prot: {=u8:?}, fifocfg: {:?} }}",
self.src_per(),
self.dst_per(),
self.src_h2sel(),
self.dst_h2sel(),
self.sod(),
self.lock_if(),
self.lock_b(),
self.lock_if_l(),
self.ahb_prot(),
self.fifocfg()
)
}
}
#[doc = "DMAC Channel Handler Disable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Chdr(pub u32);
impl Chdr {
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Disable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn dis5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Disable \\[5:0\\]"]
#[inline(always)]
pub const fn set_dis5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Resume \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn res5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Resume \\[5:0\\]"]
#[inline(always)]
pub const fn set_res5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
}
impl Default for Chdr {
#[inline(always)]
fn default() -> Chdr {
Chdr(0)
}
}
impl core::fmt::Debug for Chdr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Chdr")
.field("dis0", &self.dis0())
.field("dis1", &self.dis1())
.field("dis2", &self.dis2())
.field("dis3", &self.dis3())
.field("dis4", &self.dis4())
.field("dis5", &self.dis5())
.field("res0", &self.res0())
.field("res1", &self.res1())
.field("res2", &self.res2())
.field("res3", &self.res3())
.field("res4", &self.res4())
.field("res5", &self.res5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Chdr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Chdr {{ dis0: {=bool:?}, dis1: {=bool:?}, dis2: {=bool:?}, dis3: {=bool:?}, dis4: {=bool:?}, dis5: {=bool:?}, res0: {=bool:?}, res1: {=bool:?}, res2: {=bool:?}, res3: {=bool:?}, res4: {=bool:?}, res5: {=bool:?} }}",
self.dis0(),
self.dis1(),
self.dis2(),
self.dis3(),
self.dis4(),
self.dis5(),
self.res0(),
self.res1(),
self.res2(),
self.res3(),
self.res4(),
self.res5()
)
}
}
#[doc = "DMAC Channel Handler Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Cher(pub u32);
impl Cher {
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep0(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep1(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep2(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep3(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep4(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "Keep on \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn keep5(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Keep on \\[5:0\\]"]
#[inline(always)]
pub const fn set_keep5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Cher {
#[inline(always)]
fn default() -> Cher {
Cher(0)
}
}
impl core::fmt::Debug for Cher {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Cher")
.field("ena0", &self.ena0())
.field("ena1", &self.ena1())
.field("ena2", &self.ena2())
.field("ena3", &self.ena3())
.field("ena4", &self.ena4())
.field("ena5", &self.ena5())
.field("susp0", &self.susp0())
.field("susp1", &self.susp1())
.field("susp2", &self.susp2())
.field("susp3", &self.susp3())
.field("susp4", &self.susp4())
.field("susp5", &self.susp5())
.field("keep0", &self.keep0())
.field("keep1", &self.keep1())
.field("keep2", &self.keep2())
.field("keep3", &self.keep3())
.field("keep4", &self.keep4())
.field("keep5", &self.keep5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Cher {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Cher {{ ena0: {=bool:?}, ena1: {=bool:?}, ena2: {=bool:?}, ena3: {=bool:?}, ena4: {=bool:?}, ena5: {=bool:?}, susp0: {=bool:?}, susp1: {=bool:?}, susp2: {=bool:?}, susp3: {=bool:?}, susp4: {=bool:?}, susp5: {=bool:?}, keep0: {=bool:?}, keep1: {=bool:?}, keep2: {=bool:?}, keep3: {=bool:?}, keep4: {=bool:?}, keep5: {=bool:?} }}",
self.ena0(),
self.ena1(),
self.ena2(),
self.ena3(),
self.ena4(),
self.ena5(),
self.susp0(),
self.susp1(),
self.susp2(),
self.susp3(),
self.susp4(),
self.susp5(),
self.keep0(),
self.keep1(),
self.keep2(),
self.keep3(),
self.keep4(),
self.keep5()
)
}
}
#[doc = "DMAC Channel Handler Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Chsr(pub u32);
impl Chsr {
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Enable \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn ena5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Enable \\[5:0\\]"]
#[inline(always)]
pub const fn set_ena5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Suspend \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn susp5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Suspend \\[5:0\\]"]
#[inline(always)]
pub const fn set_susp5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt0(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt1(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt2(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt3(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt4(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Empty \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn empt5(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Empty \\[5:0\\]"]
#[inline(always)]
pub const fn set_empt5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal0(&self) -> bool {
let val = (self.0 >> 24usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal1(&self) -> bool {
let val = (self.0 >> 25usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal2(&self) -> bool {
let val = (self.0 >> 26usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal3(&self) -> bool {
let val = (self.0 >> 27usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal4(&self) -> bool {
let val = (self.0 >> 28usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
}
#[doc = "Stalled \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn stal5(&self) -> bool {
let val = (self.0 >> 29usize) & 0x01;
val != 0
}
#[doc = "Stalled \\[5:0\\]"]
#[inline(always)]
pub const fn set_stal5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
}
}
impl Default for Chsr {
#[inline(always)]
fn default() -> Chsr {
Chsr(0)
}
}
impl core::fmt::Debug for Chsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Chsr")
.field("ena0", &self.ena0())
.field("ena1", &self.ena1())
.field("ena2", &self.ena2())
.field("ena3", &self.ena3())
.field("ena4", &self.ena4())
.field("ena5", &self.ena5())
.field("susp0", &self.susp0())
.field("susp1", &self.susp1())
.field("susp2", &self.susp2())
.field("susp3", &self.susp3())
.field("susp4", &self.susp4())
.field("susp5", &self.susp5())
.field("empt0", &self.empt0())
.field("empt1", &self.empt1())
.field("empt2", &self.empt2())
.field("empt3", &self.empt3())
.field("empt4", &self.empt4())
.field("empt5", &self.empt5())
.field("stal0", &self.stal0())
.field("stal1", &self.stal1())
.field("stal2", &self.stal2())
.field("stal3", &self.stal3())
.field("stal4", &self.stal4())
.field("stal5", &self.stal5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Chsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Chsr {{ ena0: {=bool:?}, ena1: {=bool:?}, ena2: {=bool:?}, ena3: {=bool:?}, ena4: {=bool:?}, ena5: {=bool:?}, susp0: {=bool:?}, susp1: {=bool:?}, susp2: {=bool:?}, susp3: {=bool:?}, susp4: {=bool:?}, susp5: {=bool:?}, empt0: {=bool:?}, empt1: {=bool:?}, empt2: {=bool:?}, empt3: {=bool:?}, empt4: {=bool:?}, empt5: {=bool:?}, stal0: {=bool:?}, stal1: {=bool:?}, stal2: {=bool:?}, stal3: {=bool:?}, stal4: {=bool:?}, stal5: {=bool:?} }}",
self.ena0(),
self.ena1(),
self.ena2(),
self.ena3(),
self.ena4(),
self.ena5(),
self.susp0(),
self.susp1(),
self.susp2(),
self.susp3(),
self.susp4(),
self.susp5(),
self.empt0(),
self.empt1(),
self.empt2(),
self.empt3(),
self.empt4(),
self.empt5(),
self.stal0(),
self.stal1(),
self.stal2(),
self.stal3(),
self.stal4(),
self.stal5()
)
}
}
#[doc = "DMAC Software Chunk Transfer Request Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Creq(pub u32);
impl Creq {
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq0(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq1(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq1(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq2(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq2(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq3(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq3(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq4(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq4(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Source Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn screq5(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Source Chunk Request"]
#[inline(always)]
pub const fn set_screq5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Destination Chunk Request"]
#[must_use]
#[inline(always)]
pub const fn dcreq5(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Destination Chunk Request"]
#[inline(always)]
pub const fn set_dcreq5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
impl Default for Creq {
#[inline(always)]
fn default() -> Creq {
Creq(0)
}
}
impl core::fmt::Debug for Creq {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Creq")
.field("screq0", &self.screq0())
.field("dcreq0", &self.dcreq0())
.field("screq1", &self.screq1())
.field("dcreq1", &self.dcreq1())
.field("screq2", &self.screq2())
.field("dcreq2", &self.dcreq2())
.field("screq3", &self.screq3())
.field("dcreq3", &self.dcreq3())
.field("screq4", &self.screq4())
.field("dcreq4", &self.dcreq4())
.field("screq5", &self.screq5())
.field("dcreq5", &self.dcreq5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Creq {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Creq {{ screq0: {=bool:?}, dcreq0: {=bool:?}, screq1: {=bool:?}, dcreq1: {=bool:?}, screq2: {=bool:?}, dcreq2: {=bool:?}, screq3: {=bool:?}, dcreq3: {=bool:?}, screq4: {=bool:?}, dcreq4: {=bool:?}, screq5: {=bool:?}, dcreq5: {=bool:?} }}",
self.screq0(),
self.dcreq0(),
self.screq1(),
self.dcreq1(),
self.screq2(),
self.dcreq2(),
self.screq3(),
self.dcreq3(),
self.screq4(),
self.dcreq4(),
self.screq5(),
self.dcreq5()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla0(pub u32);
impl Ctrla0 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla0Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla0Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla0Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla0Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla0Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla0Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla0SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla0SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla0SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla0DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla0DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla0DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla0 {
#[inline(always)]
fn default() -> Ctrla0 {
Ctrla0(0)
}
}
impl core::fmt::Debug for Ctrla0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla0")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla0 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla1(pub u32);
impl Ctrla1 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla1Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla1Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla1Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla1Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla1Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla1Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla1SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla1SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla1SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla1DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla1DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla1DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla1 {
#[inline(always)]
fn default() -> Ctrla1 {
Ctrla1(0)
}
}
impl core::fmt::Debug for Ctrla1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla1")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla1 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla2(pub u32);
impl Ctrla2 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla2Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla2Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla2Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla2Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla2Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla2Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla2SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla2SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla2SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla2DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla2DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla2DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla2 {
#[inline(always)]
fn default() -> Ctrla2 {
Ctrla2(0)
}
}
impl core::fmt::Debug for Ctrla2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla2")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla2 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla3(pub u32);
impl Ctrla3 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla3Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla3Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla3Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla3Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla3Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla3Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla3SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla3SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla3SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla3DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla3DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla3DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla3 {
#[inline(always)]
fn default() -> Ctrla3 {
Ctrla3(0)
}
}
impl core::fmt::Debug for Ctrla3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla3")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla3 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla4(pub u32);
impl Ctrla4 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla4Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla4Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla4Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla4Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla4Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla4Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla4SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla4SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla4SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla4DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla4DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla4DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla4 {
#[inline(always)]
fn default() -> Ctrla4 {
Ctrla4(0)
}
}
impl core::fmt::Debug for Ctrla4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla4")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla4 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control A Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrla5(pub u32);
impl Ctrla5 {
#[doc = "Buffer Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn btsize(&self) -> u16 {
let val = (self.0 >> 0usize) & 0xffff;
val as u16
}
#[doc = "Buffer Transfer Size"]
#[inline(always)]
pub const fn set_btsize(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u32) & 0xffff) << 0usize);
}
#[doc = "Source Chunk Transfer Size."]
#[must_use]
#[inline(always)]
pub const fn scsize(&self) -> super::vals::Ctrla5Scsize {
let val = (self.0 >> 16usize) & 0x07;
super::vals::Ctrla5Scsize::from_bits(val as u8)
}
#[doc = "Source Chunk Transfer Size."]
#[inline(always)]
pub const fn set_scsize(&mut self, val: super::vals::Ctrla5Scsize) {
self.0 = (self.0 & !(0x07 << 16usize)) | (((val.to_bits() as u32) & 0x07) << 16usize);
}
#[doc = "Destination Chunk Transfer Size"]
#[must_use]
#[inline(always)]
pub const fn dcsize(&self) -> super::vals::Ctrla5Dcsize {
let val = (self.0 >> 20usize) & 0x07;
super::vals::Ctrla5Dcsize::from_bits(val as u8)
}
#[doc = "Destination Chunk Transfer Size"]
#[inline(always)]
pub const fn set_dcsize(&mut self, val: super::vals::Ctrla5Dcsize) {
self.0 = (self.0 & !(0x07 << 20usize)) | (((val.to_bits() as u32) & 0x07) << 20usize);
}
#[doc = "Transfer Width for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_width(&self) -> super::vals::Ctrla5SrcWidth {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrla5SrcWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Source"]
#[inline(always)]
pub const fn set_src_width(&mut self, val: super::vals::Ctrla5SrcWidth) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Transfer Width for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_width(&self) -> super::vals::Ctrla5DstWidth {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrla5DstWidth::from_bits(val as u8)
}
#[doc = "Transfer Width for the Destination"]
#[inline(always)]
pub const fn set_dst_width(&mut self, val: super::vals::Ctrla5DstWidth) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[must_use]
#[inline(always)]
pub const fn done(&self) -> bool {
let val = (self.0 >> 31usize) & 0x01;
val != 0
}
#[doc = "Current Descriptor Stop Command and Transfer Completed Memory Indicator"]
#[inline(always)]
pub const fn set_done(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
}
}
impl Default for Ctrla5 {
#[inline(always)]
fn default() -> Ctrla5 {
Ctrla5(0)
}
}
impl core::fmt::Debug for Ctrla5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrla5")
.field("btsize", &self.btsize())
.field("scsize", &self.scsize())
.field("dcsize", &self.dcsize())
.field("src_width", &self.src_width())
.field("dst_width", &self.dst_width())
.field("done", &self.done())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrla5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrla5 {{ btsize: {=u16:?}, scsize: {:?}, dcsize: {:?}, src_width: {:?}, dst_width: {:?}, done: {=bool:?} }}",
self.btsize(),
self.scsize(),
self.dcsize(),
self.src_width(),
self.dst_width(),
self.done()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb0(pub u32);
impl Ctrlb0 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb0SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb0SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb0SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb0DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb0DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb0DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb0Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb0Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb0Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb0SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb0SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb0SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb0DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb0DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb0DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb0 {
#[inline(always)]
fn default() -> Ctrlb0 {
Ctrlb0(0)
}
}
impl core::fmt::Debug for Ctrlb0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb0")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb0 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb1(pub u32);
impl Ctrlb1 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb1SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb1SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb1SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb1DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb1DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb1DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb1Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb1Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb1Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb1SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb1SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb1SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb1DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb1DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb1DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb1 {
#[inline(always)]
fn default() -> Ctrlb1 {
Ctrlb1(0)
}
}
impl core::fmt::Debug for Ctrlb1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb1")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb1 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb2(pub u32);
impl Ctrlb2 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb2SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb2SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb2SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb2DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb2DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb2DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb2Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb2Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb2Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb2SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb2SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb2SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb2DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb2DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb2DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb2 {
#[inline(always)]
fn default() -> Ctrlb2 {
Ctrlb2(0)
}
}
impl core::fmt::Debug for Ctrlb2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb2")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb2 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb3(pub u32);
impl Ctrlb3 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb3SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb3SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb3SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb3DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb3DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb3DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb3Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb3Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb3Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb3SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb3SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb3SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb3DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb3DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb3DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb3 {
#[inline(always)]
fn default() -> Ctrlb3 {
Ctrlb3(0)
}
}
impl core::fmt::Debug for Ctrlb3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb3")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb3 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb4(pub u32);
impl Ctrlb4 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb4SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb4SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb4SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb4DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb4DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb4DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb4Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb4Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb4Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb4SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb4SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb4SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb4DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb4DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb4DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb4 {
#[inline(always)]
fn default() -> Ctrlb4 {
Ctrlb4(0)
}
}
impl core::fmt::Debug for Ctrlb4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb4")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb4 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Control B Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ctrlb5(pub u32);
impl Ctrlb5 {
#[doc = "Source Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn src_dscr(&self) -> super::vals::Ctrlb5SrcDscr {
let val = (self.0 >> 16usize) & 0x01;
super::vals::Ctrlb5SrcDscr::from_bits(val as u8)
}
#[doc = "Source Address Descriptor"]
#[inline(always)]
pub const fn set_src_dscr(&mut self, val: super::vals::Ctrlb5SrcDscr) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val.to_bits() as u32) & 0x01) << 16usize);
}
#[doc = "Destination Address Descriptor"]
#[must_use]
#[inline(always)]
pub const fn dst_dscr(&self) -> super::vals::Ctrlb5DstDscr {
let val = (self.0 >> 20usize) & 0x01;
super::vals::Ctrlb5DstDscr::from_bits(val as u8)
}
#[doc = "Destination Address Descriptor"]
#[inline(always)]
pub const fn set_dst_dscr(&mut self, val: super::vals::Ctrlb5DstDscr) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val.to_bits() as u32) & 0x01) << 20usize);
}
#[doc = "Flow Control"]
#[must_use]
#[inline(always)]
pub const fn fc(&self) -> super::vals::Ctrlb5Fc {
let val = (self.0 >> 21usize) & 0x03;
super::vals::Ctrlb5Fc::from_bits(val as u8)
}
#[doc = "Flow Control"]
#[inline(always)]
pub const fn set_fc(&mut self, val: super::vals::Ctrlb5Fc) {
self.0 = (self.0 & !(0x03 << 21usize)) | (((val.to_bits() as u32) & 0x03) << 21usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[must_use]
#[inline(always)]
pub const fn src_incr(&self) -> super::vals::Ctrlb5SrcIncr {
let val = (self.0 >> 24usize) & 0x03;
super::vals::Ctrlb5SrcIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Source"]
#[inline(always)]
pub const fn set_src_incr(&mut self, val: super::vals::Ctrlb5SrcIncr) {
self.0 = (self.0 & !(0x03 << 24usize)) | (((val.to_bits() as u32) & 0x03) << 24usize);
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[must_use]
#[inline(always)]
pub const fn dst_incr(&self) -> super::vals::Ctrlb5DstIncr {
let val = (self.0 >> 28usize) & 0x03;
super::vals::Ctrlb5DstIncr::from_bits(val as u8)
}
#[doc = "Incrementing, Decrementing or Fixed Address for the Destination"]
#[inline(always)]
pub const fn set_dst_incr(&mut self, val: super::vals::Ctrlb5DstIncr) {
self.0 = (self.0 & !(0x03 << 28usize)) | (((val.to_bits() as u32) & 0x03) << 28usize);
}
#[doc = "Interrupt Enable Not"]
#[must_use]
#[inline(always)]
pub const fn ien(&self) -> bool {
let val = (self.0 >> 30usize) & 0x01;
val != 0
}
#[doc = "Interrupt Enable Not"]
#[inline(always)]
pub const fn set_ien(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
}
}
impl Default for Ctrlb5 {
#[inline(always)]
fn default() -> Ctrlb5 {
Ctrlb5(0)
}
}
impl core::fmt::Debug for Ctrlb5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ctrlb5")
.field("src_dscr", &self.src_dscr())
.field("dst_dscr", &self.dst_dscr())
.field("fc", &self.fc())
.field("src_incr", &self.src_incr())
.field("dst_incr", &self.dst_incr())
.field("ien", &self.ien())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ctrlb5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ctrlb5 {{ src_dscr: {:?}, dst_dscr: {:?}, fc: {:?}, src_incr: {:?}, dst_incr: {:?}, ien: {=bool:?} }}",
self.src_dscr(),
self.dst_dscr(),
self.fc(),
self.src_incr(),
self.dst_incr(),
self.ien()
)
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr0(pub u32);
impl Daddr0 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr0 {
#[inline(always)]
fn default() -> Daddr0 {
Daddr0(0)
}
}
impl core::fmt::Debug for Daddr0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr0")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr0 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr1(pub u32);
impl Daddr1 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr1 {
#[inline(always)]
fn default() -> Daddr1 {
Daddr1(0)
}
}
impl core::fmt::Debug for Daddr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr1")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr1 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr2(pub u32);
impl Daddr2 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr2 {
#[inline(always)]
fn default() -> Daddr2 {
Daddr2(0)
}
}
impl core::fmt::Debug for Daddr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr2")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr2 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr3(pub u32);
impl Daddr3 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr3 {
#[inline(always)]
fn default() -> Daddr3 {
Daddr3(0)
}
}
impl core::fmt::Debug for Daddr3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr3")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr3 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr4(pub u32);
impl Daddr4 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr4 {
#[inline(always)]
fn default() -> Daddr4 {
Daddr4(0)
}
}
impl core::fmt::Debug for Daddr4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr4")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr4 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Destination Address Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Daddr5(pub u32);
impl Daddr5 {
#[doc = "Channel x Destination Address"]
#[must_use]
#[inline(always)]
pub const fn daddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Destination Address"]
#[inline(always)]
pub const fn set_daddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Daddr5 {
#[inline(always)]
fn default() -> Daddr5 {
Daddr5(0)
}
}
impl core::fmt::Debug for Daddr5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Daddr5")
.field("daddr", &self.daddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Daddr5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Daddr5 {{ daddr: {=u32:?} }}", self.daddr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr0(pub u32);
impl Dscr0 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr0 {
#[inline(always)]
fn default() -> Dscr0 {
Dscr0(0)
}
}
impl core::fmt::Debug for Dscr0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr0").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr0 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr1(pub u32);
impl Dscr1 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr1 {
#[inline(always)]
fn default() -> Dscr1 {
Dscr1(0)
}
}
impl core::fmt::Debug for Dscr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr1").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr1 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr2(pub u32);
impl Dscr2 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr2 {
#[inline(always)]
fn default() -> Dscr2 {
Dscr2(0)
}
}
impl core::fmt::Debug for Dscr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr2").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr2 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr3(pub u32);
impl Dscr3 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr3 {
#[inline(always)]
fn default() -> Dscr3 {
Dscr3(0)
}
}
impl core::fmt::Debug for Dscr3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr3").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr3 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr4(pub u32);
impl Dscr4 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr4 {
#[inline(always)]
fn default() -> Dscr4 {
Dscr4(0)
}
}
impl core::fmt::Debug for Dscr4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr4").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr4 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Channel Descriptor Address Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Dscr5(pub u32);
impl Dscr5 {
#[doc = "Buffer Transfer Descriptor Address"]
#[must_use]
#[inline(always)]
pub const fn dscr(&self) -> u32 {
let val = (self.0 >> 2usize) & 0x3fff_ffff;
val as u32
}
#[doc = "Buffer Transfer Descriptor Address"]
#[inline(always)]
pub const fn set_dscr(&mut self, val: u32) {
self.0 = (self.0 & !(0x3fff_ffff << 2usize)) | (((val as u32) & 0x3fff_ffff) << 2usize);
}
}
impl Default for Dscr5 {
#[inline(always)]
fn default() -> Dscr5 {
Dscr5(0)
}
}
impl core::fmt::Debug for Dscr5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Dscr5").field("dscr", &self.dscr()).finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Dscr5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Dscr5 {{ dscr: {=u32:?} }}", self.dscr())
}
}
#[doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Disable register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ebcidr(pub u32);
impl Ebcidr {
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err0(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err1(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err2(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err3(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err4(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err5(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
}
impl Default for Ebcidr {
#[inline(always)]
fn default() -> Ebcidr {
Ebcidr(0)
}
}
impl core::fmt::Debug for Ebcidr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ebcidr")
.field("btc0", &self.btc0())
.field("btc1", &self.btc1())
.field("btc2", &self.btc2())
.field("btc3", &self.btc3())
.field("btc4", &self.btc4())
.field("btc5", &self.btc5())
.field("cbtc0", &self.cbtc0())
.field("cbtc1", &self.cbtc1())
.field("cbtc2", &self.cbtc2())
.field("cbtc3", &self.cbtc3())
.field("cbtc4", &self.cbtc4())
.field("cbtc5", &self.cbtc5())
.field("err0", &self.err0())
.field("err1", &self.err1())
.field("err2", &self.err2())
.field("err3", &self.err3())
.field("err4", &self.err4())
.field("err5", &self.err5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ebcidr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ebcidr {{ btc0: {=bool:?}, btc1: {=bool:?}, btc2: {=bool:?}, btc3: {=bool:?}, btc4: {=bool:?}, btc5: {=bool:?}, cbtc0: {=bool:?}, cbtc1: {=bool:?}, cbtc2: {=bool:?}, cbtc3: {=bool:?}, cbtc4: {=bool:?}, cbtc5: {=bool:?}, err0: {=bool:?}, err1: {=bool:?}, err2: {=bool:?}, err3: {=bool:?}, err4: {=bool:?}, err5: {=bool:?} }}",
self.btc0(),
self.btc1(),
self.btc2(),
self.btc3(),
self.btc4(),
self.btc5(),
self.cbtc0(),
self.cbtc1(),
self.cbtc2(),
self.cbtc3(),
self.cbtc4(),
self.cbtc5(),
self.err0(),
self.err1(),
self.err2(),
self.err3(),
self.err4(),
self.err5()
)
}
}
#[doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer Transfer Completed Interrupt Enable register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ebcier(pub u32);
impl Ebcier {
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err0(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err1(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err2(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err3(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err4(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err5(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
}
impl Default for Ebcier {
#[inline(always)]
fn default() -> Ebcier {
Ebcier(0)
}
}
impl core::fmt::Debug for Ebcier {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ebcier")
.field("btc0", &self.btc0())
.field("btc1", &self.btc1())
.field("btc2", &self.btc2())
.field("btc3", &self.btc3())
.field("btc4", &self.btc4())
.field("btc5", &self.btc5())
.field("cbtc0", &self.cbtc0())
.field("cbtc1", &self.cbtc1())
.field("cbtc2", &self.cbtc2())
.field("cbtc3", &self.cbtc3())
.field("cbtc4", &self.cbtc4())
.field("cbtc5", &self.cbtc5())
.field("err0", &self.err0())
.field("err1", &self.err1())
.field("err2", &self.err2())
.field("err3", &self.err3())
.field("err4", &self.err4())
.field("err5", &self.err5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ebcier {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ebcier {{ btc0: {=bool:?}, btc1: {=bool:?}, btc2: {=bool:?}, btc3: {=bool:?}, btc4: {=bool:?}, btc5: {=bool:?}, cbtc0: {=bool:?}, cbtc1: {=bool:?}, cbtc2: {=bool:?}, cbtc3: {=bool:?}, cbtc4: {=bool:?}, cbtc5: {=bool:?}, err0: {=bool:?}, err1: {=bool:?}, err2: {=bool:?}, err3: {=bool:?}, err4: {=bool:?}, err5: {=bool:?} }}",
self.btc0(),
self.btc1(),
self.btc2(),
self.btc3(),
self.btc4(),
self.btc5(),
self.cbtc0(),
self.cbtc1(),
self.cbtc2(),
self.cbtc3(),
self.cbtc4(),
self.cbtc5(),
self.err0(),
self.err1(),
self.err2(),
self.err3(),
self.err4(),
self.err5()
)
}
}
#[doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Mask Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ebcimr(pub u32);
impl Ebcimr {
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err0(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err1(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err2(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err3(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err4(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err5(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
}
impl Default for Ebcimr {
#[inline(always)]
fn default() -> Ebcimr {
Ebcimr(0)
}
}
impl core::fmt::Debug for Ebcimr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ebcimr")
.field("btc0", &self.btc0())
.field("btc1", &self.btc1())
.field("btc2", &self.btc2())
.field("btc3", &self.btc3())
.field("btc4", &self.btc4())
.field("btc5", &self.btc5())
.field("cbtc0", &self.cbtc0())
.field("cbtc1", &self.cbtc1())
.field("cbtc2", &self.cbtc2())
.field("cbtc3", &self.cbtc3())
.field("cbtc4", &self.cbtc4())
.field("cbtc5", &self.cbtc5())
.field("err0", &self.err0())
.field("err1", &self.err1())
.field("err2", &self.err2())
.field("err3", &self.err3())
.field("err4", &self.err4())
.field("err5", &self.err5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ebcimr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ebcimr {{ btc0: {=bool:?}, btc1: {=bool:?}, btc2: {=bool:?}, btc3: {=bool:?}, btc4: {=bool:?}, btc5: {=bool:?}, cbtc0: {=bool:?}, cbtc1: {=bool:?}, cbtc2: {=bool:?}, cbtc3: {=bool:?}, cbtc4: {=bool:?}, cbtc5: {=bool:?}, err0: {=bool:?}, err1: {=bool:?}, err2: {=bool:?}, err3: {=bool:?}, err4: {=bool:?}, err5: {=bool:?} }}",
self.btc0(),
self.btc1(),
self.btc2(),
self.btc3(),
self.btc4(),
self.btc5(),
self.cbtc0(),
self.cbtc1(),
self.cbtc2(),
self.cbtc3(),
self.cbtc4(),
self.cbtc5(),
self.err0(),
self.err1(),
self.err2(),
self.err3(),
self.err4(),
self.err5()
)
}
}
#[doc = "DMAC Error, Chained Buffer Transfer Completed Interrupt and Buffer transfer completed Status Register."]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Ebcisr(pub u32);
impl Ebcisr {
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc1(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc2(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc3(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc4(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn btc5(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_btc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc0(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc1(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc2(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc3(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc4(&self) -> bool {
let val = (self.0 >> 12usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn cbtc5(&self) -> bool {
let val = (self.0 >> 13usize) & 0x01;
val != 0
}
#[doc = "Chained Buffer Transfer Completed \\[5:0\\]"]
#[inline(always)]
pub const fn set_cbtc5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err0(&self) -> bool {
let val = (self.0 >> 16usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err1(&self) -> bool {
let val = (self.0 >> 17usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err2(&self) -> bool {
let val = (self.0 >> 18usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err3(&self) -> bool {
let val = (self.0 >> 19usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err4(&self) -> bool {
let val = (self.0 >> 20usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
}
#[doc = "Access Error \\[5:0\\]"]
#[must_use]
#[inline(always)]
pub const fn err5(&self) -> bool {
let val = (self.0 >> 21usize) & 0x01;
val != 0
}
#[doc = "Access Error \\[5:0\\]"]
#[inline(always)]
pub const fn set_err5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
}
}
impl Default for Ebcisr {
#[inline(always)]
fn default() -> Ebcisr {
Ebcisr(0)
}
}
impl core::fmt::Debug for Ebcisr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Ebcisr")
.field("btc0", &self.btc0())
.field("btc1", &self.btc1())
.field("btc2", &self.btc2())
.field("btc3", &self.btc3())
.field("btc4", &self.btc4())
.field("btc5", &self.btc5())
.field("cbtc0", &self.cbtc0())
.field("cbtc1", &self.cbtc1())
.field("cbtc2", &self.cbtc2())
.field("cbtc3", &self.cbtc3())
.field("cbtc4", &self.cbtc4())
.field("cbtc5", &self.cbtc5())
.field("err0", &self.err0())
.field("err1", &self.err1())
.field("err2", &self.err2())
.field("err3", &self.err3())
.field("err4", &self.err4())
.field("err5", &self.err5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Ebcisr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Ebcisr {{ btc0: {=bool:?}, btc1: {=bool:?}, btc2: {=bool:?}, btc3: {=bool:?}, btc4: {=bool:?}, btc5: {=bool:?}, cbtc0: {=bool:?}, cbtc1: {=bool:?}, cbtc2: {=bool:?}, cbtc3: {=bool:?}, cbtc4: {=bool:?}, cbtc5: {=bool:?}, err0: {=bool:?}, err1: {=bool:?}, err2: {=bool:?}, err3: {=bool:?}, err4: {=bool:?}, err5: {=bool:?} }}",
self.btc0(),
self.btc1(),
self.btc2(),
self.btc3(),
self.btc4(),
self.btc5(),
self.cbtc0(),
self.cbtc1(),
self.cbtc2(),
self.cbtc3(),
self.cbtc4(),
self.cbtc5(),
self.err0(),
self.err1(),
self.err2(),
self.err3(),
self.err4(),
self.err5()
)
}
}
#[doc = "DMAC Enable Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct En(pub u32);
impl En {
#[doc = "General Enable of DMA"]
#[must_use]
#[inline(always)]
pub const fn enable(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "General Enable of DMA"]
#[inline(always)]
pub const fn set_enable(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
}
impl Default for En {
#[inline(always)]
fn default() -> En {
En(0)
}
}
impl core::fmt::Debug for En {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("En")
.field("enable", &self.enable())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for En {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "En {{ enable: {=bool:?} }}", self.enable())
}
}
#[doc = "DMAC Global Configuration Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Gcfg(pub u32);
impl Gcfg {
#[doc = "Arbiter Configuration"]
#[must_use]
#[inline(always)]
pub const fn arb_cfg(&self) -> super::vals::ArbCfg {
let val = (self.0 >> 4usize) & 0x01;
super::vals::ArbCfg::from_bits(val as u8)
}
#[doc = "Arbiter Configuration"]
#[inline(always)]
pub const fn set_arb_cfg(&mut self, val: super::vals::ArbCfg) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val.to_bits() as u32) & 0x01) << 4usize);
}
}
impl Default for Gcfg {
#[inline(always)]
fn default() -> Gcfg {
Gcfg(0)
}
}
impl core::fmt::Debug for Gcfg {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Gcfg")
.field("arb_cfg", &self.arb_cfg())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Gcfg {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Gcfg {{ arb_cfg: {:?} }}", self.arb_cfg())
}
}
#[doc = "DMAC Software Last Transfer Flag Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Last(pub u32);
impl Last {
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast0(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast1(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast1(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast2(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast2(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast3(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast3(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast4(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast4(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Source Last"]
#[must_use]
#[inline(always)]
pub const fn slast5(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Source Last"]
#[inline(always)]
pub const fn set_slast5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Destination Last"]
#[must_use]
#[inline(always)]
pub const fn dlast5(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Destination Last"]
#[inline(always)]
pub const fn set_dlast5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
impl Default for Last {
#[inline(always)]
fn default() -> Last {
Last(0)
}
}
impl core::fmt::Debug for Last {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Last")
.field("slast0", &self.slast0())
.field("dlast0", &self.dlast0())
.field("slast1", &self.slast1())
.field("dlast1", &self.dlast1())
.field("slast2", &self.slast2())
.field("dlast2", &self.dlast2())
.field("slast3", &self.slast3())
.field("dlast3", &self.dlast3())
.field("slast4", &self.slast4())
.field("dlast4", &self.dlast4())
.field("slast5", &self.slast5())
.field("dlast5", &self.dlast5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Last {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Last {{ slast0: {=bool:?}, dlast0: {=bool:?}, slast1: {=bool:?}, dlast1: {=bool:?}, slast2: {=bool:?}, dlast2: {=bool:?}, slast3: {=bool:?}, dlast3: {=bool:?}, slast4: {=bool:?}, dlast4: {=bool:?}, slast5: {=bool:?}, dlast5: {=bool:?} }}",
self.slast0(),
self.dlast0(),
self.slast1(),
self.dlast1(),
self.slast2(),
self.dlast2(),
self.slast3(),
self.dlast3(),
self.slast4(),
self.dlast4(),
self.slast5(),
self.dlast5()
)
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 0)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr0(pub u32);
impl Saddr0 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr0 {
#[inline(always)]
fn default() -> Saddr0 {
Saddr0(0)
}
}
impl core::fmt::Debug for Saddr0 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr0")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr0 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr0 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 1)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr1(pub u32);
impl Saddr1 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr1 {
#[inline(always)]
fn default() -> Saddr1 {
Saddr1(0)
}
}
impl core::fmt::Debug for Saddr1 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr1")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr1 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr1 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 2)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr2(pub u32);
impl Saddr2 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr2 {
#[inline(always)]
fn default() -> Saddr2 {
Saddr2(0)
}
}
impl core::fmt::Debug for Saddr2 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr2")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr2 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr2 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 3)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr3(pub u32);
impl Saddr3 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr3 {
#[inline(always)]
fn default() -> Saddr3 {
Saddr3(0)
}
}
impl core::fmt::Debug for Saddr3 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr3")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr3 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr3 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 4)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr4(pub u32);
impl Saddr4 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr4 {
#[inline(always)]
fn default() -> Saddr4 {
Saddr4(0)
}
}
impl core::fmt::Debug for Saddr4 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr4")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr4 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr4 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Channel Source Address Register (ch_num = 5)"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Saddr5(pub u32);
impl Saddr5 {
#[doc = "Channel x Source Address"]
#[must_use]
#[inline(always)]
pub const fn saddr(&self) -> u32 {
let val = (self.0 >> 0usize) & 0xffff_ffff;
val as u32
}
#[doc = "Channel x Source Address"]
#[inline(always)]
pub const fn set_saddr(&mut self, val: u32) {
self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
}
}
impl Default for Saddr5 {
#[inline(always)]
fn default() -> Saddr5 {
Saddr5(0)
}
}
impl core::fmt::Debug for Saddr5 {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Saddr5")
.field("saddr", &self.saddr())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Saddr5 {
fn format(&self, f: defmt::Formatter) {
defmt::write!(f, "Saddr5 {{ saddr: {=u32:?} }}", self.saddr())
}
}
#[doc = "DMAC Software Single Request Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Sreq(pub u32);
impl Sreq {
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq0(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq0(&self) -> bool {
let val = (self.0 >> 1usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq0(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
}
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq1(&self) -> bool {
let val = (self.0 >> 2usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq1(&self) -> bool {
let val = (self.0 >> 3usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq1(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
}
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq2(&self) -> bool {
let val = (self.0 >> 4usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq2(&self) -> bool {
let val = (self.0 >> 5usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq2(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
}
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq3(&self) -> bool {
let val = (self.0 >> 6usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq3(&self) -> bool {
let val = (self.0 >> 7usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq3(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
}
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq4(&self) -> bool {
let val = (self.0 >> 8usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq4(&self) -> bool {
let val = (self.0 >> 9usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq4(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
}
#[doc = "Source Request"]
#[must_use]
#[inline(always)]
pub const fn ssreq5(&self) -> bool {
let val = (self.0 >> 10usize) & 0x01;
val != 0
}
#[doc = "Source Request"]
#[inline(always)]
pub const fn set_ssreq5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
}
#[doc = "Destination Request"]
#[must_use]
#[inline(always)]
pub const fn dsreq5(&self) -> bool {
let val = (self.0 >> 11usize) & 0x01;
val != 0
}
#[doc = "Destination Request"]
#[inline(always)]
pub const fn set_dsreq5(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
}
}
impl Default for Sreq {
#[inline(always)]
fn default() -> Sreq {
Sreq(0)
}
}
impl core::fmt::Debug for Sreq {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Sreq")
.field("ssreq0", &self.ssreq0())
.field("dsreq0", &self.dsreq0())
.field("ssreq1", &self.ssreq1())
.field("dsreq1", &self.dsreq1())
.field("ssreq2", &self.ssreq2())
.field("dsreq2", &self.dsreq2())
.field("ssreq3", &self.ssreq3())
.field("dsreq3", &self.dsreq3())
.field("ssreq4", &self.ssreq4())
.field("dsreq4", &self.dsreq4())
.field("ssreq5", &self.ssreq5())
.field("dsreq5", &self.dsreq5())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Sreq {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Sreq {{ ssreq0: {=bool:?}, dsreq0: {=bool:?}, ssreq1: {=bool:?}, dsreq1: {=bool:?}, ssreq2: {=bool:?}, dsreq2: {=bool:?}, ssreq3: {=bool:?}, dsreq3: {=bool:?}, ssreq4: {=bool:?}, dsreq4: {=bool:?}, ssreq5: {=bool:?}, dsreq5: {=bool:?} }}",
self.ssreq0(),
self.dsreq0(),
self.ssreq1(),
self.dsreq1(),
self.ssreq2(),
self.dsreq2(),
self.ssreq3(),
self.dsreq3(),
self.ssreq4(),
self.dsreq4(),
self.ssreq5(),
self.dsreq5()
)
}
}
#[doc = "DMAC Write Protect Mode Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpmr(pub u32);
impl Wpmr {
#[doc = "Write Protect Enable"]
#[must_use]
#[inline(always)]
pub const fn wpen(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write Protect Enable"]
#[inline(always)]
pub const fn set_wpen(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Write Protect KEY"]
#[must_use]
#[inline(always)]
pub const fn wpkey(&self) -> super::vals::Wpkey {
let val = (self.0 >> 8usize) & 0x00ff_ffff;
super::vals::Wpkey::from_bits(val as u32)
}
#[doc = "Write Protect KEY"]
#[inline(always)]
pub const fn set_wpkey(&mut self, val: super::vals::Wpkey) {
self.0 = (self.0 & !(0x00ff_ffff << 8usize))
| (((val.to_bits() as u32) & 0x00ff_ffff) << 8usize);
}
}
impl Default for Wpmr {
#[inline(always)]
fn default() -> Wpmr {
Wpmr(0)
}
}
impl core::fmt::Debug for Wpmr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wpmr")
.field("wpen", &self.wpen())
.field("wpkey", &self.wpkey())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpmr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Wpmr {{ wpen: {=bool:?}, wpkey: {:?} }}",
self.wpen(),
self.wpkey()
)
}
}
#[doc = "DMAC Write Protect Status Register"]
#[repr(transparent)]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Wpsr(pub u32);
impl Wpsr {
#[doc = "Write Protect Violation Status"]
#[must_use]
#[inline(always)]
pub const fn wpvs(&self) -> bool {
let val = (self.0 >> 0usize) & 0x01;
val != 0
}
#[doc = "Write Protect Violation Status"]
#[inline(always)]
pub const fn set_wpvs(&mut self, val: bool) {
self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
}
#[doc = "Write Protect Violation Source"]
#[must_use]
#[inline(always)]
pub const fn wpvsrc(&self) -> u16 {
let val = (self.0 >> 8usize) & 0xffff;
val as u16
}
#[doc = "Write Protect Violation Source"]
#[inline(always)]
pub const fn set_wpvsrc(&mut self, val: u16) {
self.0 = (self.0 & !(0xffff << 8usize)) | (((val as u32) & 0xffff) << 8usize);
}
}
impl Default for Wpsr {
#[inline(always)]
fn default() -> Wpsr {
Wpsr(0)
}
}
impl core::fmt::Debug for Wpsr {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("Wpsr")
.field("wpvs", &self.wpvs())
.field("wpvsrc", &self.wpvsrc())
.finish()
}
}
#[cfg(feature = "defmt")]
impl defmt::Format for Wpsr {
fn format(&self, f: defmt::Formatter) {
defmt::write!(
f,
"Wpsr {{ wpvs: {=bool:?}, wpvsrc: {=u16:?} }}",
self.wpvs(),
self.wpvsrc()
)
}
}