#[doc = r"Value read from the register"]
pub struct R {
bits: u32,
}
#[doc = r"Value to write to the register"]
pub struct W {
bits: u32,
}
impl super::FFA1R {
#[doc = r"Modifies the contents of the register"]
#[inline(always)]
pub fn modify<F>(&self, f: F)
where
for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
{
let bits = self.register.get();
self.register.set(f(&R { bits }, &mut W { bits }).bits);
}
#[doc = r"Reads the contents of the register"]
#[inline(always)]
pub fn read(&self) -> R {
R {
bits: self.register.get(),
}
}
#[doc = r"Writes to the register"]
#[inline(always)]
pub fn write<F>(&self, f: F)
where
F: FnOnce(&mut W) -> &mut W,
{
self.register.set(
f(&mut W {
bits: Self::reset_value(),
})
.bits,
);
}
#[doc = r"Reset value of the register"]
#[inline(always)]
pub const fn reset_value() -> u32 {
0
}
#[doc = r"Writes the reset value to the register"]
#[inline(always)]
pub fn reset(&self) {
self.register.set(Self::reset_value())
}
}
#[doc = r"Value of the field"]
pub struct FFA0R {
bits: bool,
}
impl FFA0R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA0W<'a> {
w: &'a mut W,
}
impl<'a> _FFA0W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 0);
self.w.bits |= ((value as u32) & 0x01) << 0;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA1R {
bits: bool,
}
impl FFA1R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA1W<'a> {
w: &'a mut W,
}
impl<'a> _FFA1W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 1);
self.w.bits |= ((value as u32) & 0x01) << 1;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA2R {
bits: bool,
}
impl FFA2R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA2W<'a> {
w: &'a mut W,
}
impl<'a> _FFA2W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 2);
self.w.bits |= ((value as u32) & 0x01) << 2;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA3R {
bits: bool,
}
impl FFA3R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA3W<'a> {
w: &'a mut W,
}
impl<'a> _FFA3W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 3);
self.w.bits |= ((value as u32) & 0x01) << 3;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA4R {
bits: bool,
}
impl FFA4R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA4W<'a> {
w: &'a mut W,
}
impl<'a> _FFA4W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 4);
self.w.bits |= ((value as u32) & 0x01) << 4;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA5R {
bits: bool,
}
impl FFA5R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA5W<'a> {
w: &'a mut W,
}
impl<'a> _FFA5W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 5);
self.w.bits |= ((value as u32) & 0x01) << 5;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA6R {
bits: bool,
}
impl FFA6R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA6W<'a> {
w: &'a mut W,
}
impl<'a> _FFA6W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 6);
self.w.bits |= ((value as u32) & 0x01) << 6;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA7R {
bits: bool,
}
impl FFA7R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA7W<'a> {
w: &'a mut W,
}
impl<'a> _FFA7W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 7);
self.w.bits |= ((value as u32) & 0x01) << 7;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA8R {
bits: bool,
}
impl FFA8R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA8W<'a> {
w: &'a mut W,
}
impl<'a> _FFA8W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 8);
self.w.bits |= ((value as u32) & 0x01) << 8;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA9R {
bits: bool,
}
impl FFA9R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA9W<'a> {
w: &'a mut W,
}
impl<'a> _FFA9W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 9);
self.w.bits |= ((value as u32) & 0x01) << 9;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA10R {
bits: bool,
}
impl FFA10R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA10W<'a> {
w: &'a mut W,
}
impl<'a> _FFA10W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 10);
self.w.bits |= ((value as u32) & 0x01) << 10;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA11R {
bits: bool,
}
impl FFA11R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA11W<'a> {
w: &'a mut W,
}
impl<'a> _FFA11W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 11);
self.w.bits |= ((value as u32) & 0x01) << 11;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA12R {
bits: bool,
}
impl FFA12R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA12W<'a> {
w: &'a mut W,
}
impl<'a> _FFA12W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 12);
self.w.bits |= ((value as u32) & 0x01) << 12;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA13R {
bits: bool,
}
impl FFA13R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA13W<'a> {
w: &'a mut W,
}
impl<'a> _FFA13W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 13);
self.w.bits |= ((value as u32) & 0x01) << 13;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA14R {
bits: bool,
}
impl FFA14R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA14W<'a> {
w: &'a mut W,
}
impl<'a> _FFA14W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 14);
self.w.bits |= ((value as u32) & 0x01) << 14;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA15R {
bits: bool,
}
impl FFA15R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA15W<'a> {
w: &'a mut W,
}
impl<'a> _FFA15W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 15);
self.w.bits |= ((value as u32) & 0x01) << 15;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA16R {
bits: bool,
}
impl FFA16R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA16W<'a> {
w: &'a mut W,
}
impl<'a> _FFA16W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 16);
self.w.bits |= ((value as u32) & 0x01) << 16;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA17R {
bits: bool,
}
impl FFA17R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA17W<'a> {
w: &'a mut W,
}
impl<'a> _FFA17W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 17);
self.w.bits |= ((value as u32) & 0x01) << 17;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA18R {
bits: bool,
}
impl FFA18R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA18W<'a> {
w: &'a mut W,
}
impl<'a> _FFA18W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 18);
self.w.bits |= ((value as u32) & 0x01) << 18;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA19R {
bits: bool,
}
impl FFA19R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA19W<'a> {
w: &'a mut W,
}
impl<'a> _FFA19W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 19);
self.w.bits |= ((value as u32) & 0x01) << 19;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA20R {
bits: bool,
}
impl FFA20R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA20W<'a> {
w: &'a mut W,
}
impl<'a> _FFA20W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 20);
self.w.bits |= ((value as u32) & 0x01) << 20;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA21R {
bits: bool,
}
impl FFA21R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA21W<'a> {
w: &'a mut W,
}
impl<'a> _FFA21W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 21);
self.w.bits |= ((value as u32) & 0x01) << 21;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA22R {
bits: bool,
}
impl FFA22R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA22W<'a> {
w: &'a mut W,
}
impl<'a> _FFA22W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 22);
self.w.bits |= ((value as u32) & 0x01) << 22;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA23R {
bits: bool,
}
impl FFA23R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA23W<'a> {
w: &'a mut W,
}
impl<'a> _FFA23W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 23);
self.w.bits |= ((value as u32) & 0x01) << 23;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA24R {
bits: bool,
}
impl FFA24R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA24W<'a> {
w: &'a mut W,
}
impl<'a> _FFA24W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 24);
self.w.bits |= ((value as u32) & 0x01) << 24;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA25R {
bits: bool,
}
impl FFA25R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA25W<'a> {
w: &'a mut W,
}
impl<'a> _FFA25W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 25);
self.w.bits |= ((value as u32) & 0x01) << 25;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA26R {
bits: bool,
}
impl FFA26R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA26W<'a> {
w: &'a mut W,
}
impl<'a> _FFA26W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 26);
self.w.bits |= ((value as u32) & 0x01) << 26;
self.w
}
}
#[doc = r"Value of the field"]
pub struct FFA27R {
bits: bool,
}
impl FFA27R {
#[doc = r"Value of the field as raw bits"]
#[inline(always)]
pub fn bit(&self) -> bool {
self.bits
}
#[doc = r"Returns `true` if the bit is clear (0)"]
#[inline(always)]
pub fn bit_is_clear(&self) -> bool {
!self.bit()
}
#[doc = r"Returns `true` if the bit is set (1)"]
#[inline(always)]
pub fn bit_is_set(&self) -> bool {
self.bit()
}
}
#[doc = r"Proxy"]
pub struct _FFA27W<'a> {
w: &'a mut W,
}
impl<'a> _FFA27W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits &= !(0x01 << 27);
self.w.bits |= ((value as u32) & 0x01) << 27;
self.w
}
}
impl R {
#[doc = r"Value of the register as raw bits"]
#[inline(always)]
pub fn bits(&self) -> u32 {
self.bits
}
#[doc = "Bit 0 - Filter FIFO assignment for filter 0"]
#[inline(always)]
pub fn ffa0(&self) -> FFA0R {
let bits = ((self.bits >> 0) & 0x01) != 0;
FFA0R { bits }
}
#[doc = "Bit 1 - Filter FIFO assignment for filter 1"]
#[inline(always)]
pub fn ffa1(&self) -> FFA1R {
let bits = ((self.bits >> 1) & 0x01) != 0;
FFA1R { bits }
}
#[doc = "Bit 2 - Filter FIFO assignment for filter 2"]
#[inline(always)]
pub fn ffa2(&self) -> FFA2R {
let bits = ((self.bits >> 2) & 0x01) != 0;
FFA2R { bits }
}
#[doc = "Bit 3 - Filter FIFO assignment for filter 3"]
#[inline(always)]
pub fn ffa3(&self) -> FFA3R {
let bits = ((self.bits >> 3) & 0x01) != 0;
FFA3R { bits }
}
#[doc = "Bit 4 - Filter FIFO assignment for filter 4"]
#[inline(always)]
pub fn ffa4(&self) -> FFA4R {
let bits = ((self.bits >> 4) & 0x01) != 0;
FFA4R { bits }
}
#[doc = "Bit 5 - Filter FIFO assignment for filter 5"]
#[inline(always)]
pub fn ffa5(&self) -> FFA5R {
let bits = ((self.bits >> 5) & 0x01) != 0;
FFA5R { bits }
}
#[doc = "Bit 6 - Filter FIFO assignment for filter 6"]
#[inline(always)]
pub fn ffa6(&self) -> FFA6R {
let bits = ((self.bits >> 6) & 0x01) != 0;
FFA6R { bits }
}
#[doc = "Bit 7 - Filter FIFO assignment for filter 7"]
#[inline(always)]
pub fn ffa7(&self) -> FFA7R {
let bits = ((self.bits >> 7) & 0x01) != 0;
FFA7R { bits }
}
#[doc = "Bit 8 - Filter FIFO assignment for filter 8"]
#[inline(always)]
pub fn ffa8(&self) -> FFA8R {
let bits = ((self.bits >> 8) & 0x01) != 0;
FFA8R { bits }
}
#[doc = "Bit 9 - Filter FIFO assignment for filter 9"]
#[inline(always)]
pub fn ffa9(&self) -> FFA9R {
let bits = ((self.bits >> 9) & 0x01) != 0;
FFA9R { bits }
}
#[doc = "Bit 10 - Filter FIFO assignment for filter 10"]
#[inline(always)]
pub fn ffa10(&self) -> FFA10R {
let bits = ((self.bits >> 10) & 0x01) != 0;
FFA10R { bits }
}
#[doc = "Bit 11 - Filter FIFO assignment for filter 11"]
#[inline(always)]
pub fn ffa11(&self) -> FFA11R {
let bits = ((self.bits >> 11) & 0x01) != 0;
FFA11R { bits }
}
#[doc = "Bit 12 - Filter FIFO assignment for filter 12"]
#[inline(always)]
pub fn ffa12(&self) -> FFA12R {
let bits = ((self.bits >> 12) & 0x01) != 0;
FFA12R { bits }
}
#[doc = "Bit 13 - Filter FIFO assignment for filter 13"]
#[inline(always)]
pub fn ffa13(&self) -> FFA13R {
let bits = ((self.bits >> 13) & 0x01) != 0;
FFA13R { bits }
}
#[doc = "Bit 14 - Filter FIFO assignment for filter 14"]
#[inline(always)]
pub fn ffa14(&self) -> FFA14R {
let bits = ((self.bits >> 14) & 0x01) != 0;
FFA14R { bits }
}
#[doc = "Bit 15 - Filter FIFO assignment for filter 15"]
#[inline(always)]
pub fn ffa15(&self) -> FFA15R {
let bits = ((self.bits >> 15) & 0x01) != 0;
FFA15R { bits }
}
#[doc = "Bit 16 - Filter FIFO assignment for filter 16"]
#[inline(always)]
pub fn ffa16(&self) -> FFA16R {
let bits = ((self.bits >> 16) & 0x01) != 0;
FFA16R { bits }
}
#[doc = "Bit 17 - Filter FIFO assignment for filter 17"]
#[inline(always)]
pub fn ffa17(&self) -> FFA17R {
let bits = ((self.bits >> 17) & 0x01) != 0;
FFA17R { bits }
}
#[doc = "Bit 18 - Filter FIFO assignment for filter 18"]
#[inline(always)]
pub fn ffa18(&self) -> FFA18R {
let bits = ((self.bits >> 18) & 0x01) != 0;
FFA18R { bits }
}
#[doc = "Bit 19 - Filter FIFO assignment for filter 19"]
#[inline(always)]
pub fn ffa19(&self) -> FFA19R {
let bits = ((self.bits >> 19) & 0x01) != 0;
FFA19R { bits }
}
#[doc = "Bit 20 - Filter FIFO assignment for filter 20"]
#[inline(always)]
pub fn ffa20(&self) -> FFA20R {
let bits = ((self.bits >> 20) & 0x01) != 0;
FFA20R { bits }
}
#[doc = "Bit 21 - Filter FIFO assignment for filter 21"]
#[inline(always)]
pub fn ffa21(&self) -> FFA21R {
let bits = ((self.bits >> 21) & 0x01) != 0;
FFA21R { bits }
}
#[doc = "Bit 22 - Filter FIFO assignment for filter 22"]
#[inline(always)]
pub fn ffa22(&self) -> FFA22R {
let bits = ((self.bits >> 22) & 0x01) != 0;
FFA22R { bits }
}
#[doc = "Bit 23 - Filter FIFO assignment for filter 23"]
#[inline(always)]
pub fn ffa23(&self) -> FFA23R {
let bits = ((self.bits >> 23) & 0x01) != 0;
FFA23R { bits }
}
#[doc = "Bit 24 - Filter FIFO assignment for filter 24"]
#[inline(always)]
pub fn ffa24(&self) -> FFA24R {
let bits = ((self.bits >> 24) & 0x01) != 0;
FFA24R { bits }
}
#[doc = "Bit 25 - Filter FIFO assignment for filter 25"]
#[inline(always)]
pub fn ffa25(&self) -> FFA25R {
let bits = ((self.bits >> 25) & 0x01) != 0;
FFA25R { bits }
}
#[doc = "Bit 26 - Filter FIFO assignment for filter 26"]
#[inline(always)]
pub fn ffa26(&self) -> FFA26R {
let bits = ((self.bits >> 26) & 0x01) != 0;
FFA26R { bits }
}
#[doc = "Bit 27 - Filter FIFO assignment for filter 27"]
#[inline(always)]
pub fn ffa27(&self) -> FFA27R {
let bits = ((self.bits >> 27) & 0x01) != 0;
FFA27R { bits }
}
}
impl W {
#[doc = r"Writes raw bits to the register"]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
#[doc = "Bit 0 - Filter FIFO assignment for filter 0"]
#[inline(always)]
pub fn ffa0(&mut self) -> _FFA0W {
_FFA0W { w: self }
}
#[doc = "Bit 1 - Filter FIFO assignment for filter 1"]
#[inline(always)]
pub fn ffa1(&mut self) -> _FFA1W {
_FFA1W { w: self }
}
#[doc = "Bit 2 - Filter FIFO assignment for filter 2"]
#[inline(always)]
pub fn ffa2(&mut self) -> _FFA2W {
_FFA2W { w: self }
}
#[doc = "Bit 3 - Filter FIFO assignment for filter 3"]
#[inline(always)]
pub fn ffa3(&mut self) -> _FFA3W {
_FFA3W { w: self }
}
#[doc = "Bit 4 - Filter FIFO assignment for filter 4"]
#[inline(always)]
pub fn ffa4(&mut self) -> _FFA4W {
_FFA4W { w: self }
}
#[doc = "Bit 5 - Filter FIFO assignment for filter 5"]
#[inline(always)]
pub fn ffa5(&mut self) -> _FFA5W {
_FFA5W { w: self }
}
#[doc = "Bit 6 - Filter FIFO assignment for filter 6"]
#[inline(always)]
pub fn ffa6(&mut self) -> _FFA6W {
_FFA6W { w: self }
}
#[doc = "Bit 7 - Filter FIFO assignment for filter 7"]
#[inline(always)]
pub fn ffa7(&mut self) -> _FFA7W {
_FFA7W { w: self }
}
#[doc = "Bit 8 - Filter FIFO assignment for filter 8"]
#[inline(always)]
pub fn ffa8(&mut self) -> _FFA8W {
_FFA8W { w: self }
}
#[doc = "Bit 9 - Filter FIFO assignment for filter 9"]
#[inline(always)]
pub fn ffa9(&mut self) -> _FFA9W {
_FFA9W { w: self }
}
#[doc = "Bit 10 - Filter FIFO assignment for filter 10"]
#[inline(always)]
pub fn ffa10(&mut self) -> _FFA10W {
_FFA10W { w: self }
}
#[doc = "Bit 11 - Filter FIFO assignment for filter 11"]
#[inline(always)]
pub fn ffa11(&mut self) -> _FFA11W {
_FFA11W { w: self }
}
#[doc = "Bit 12 - Filter FIFO assignment for filter 12"]
#[inline(always)]
pub fn ffa12(&mut self) -> _FFA12W {
_FFA12W { w: self }
}
#[doc = "Bit 13 - Filter FIFO assignment for filter 13"]
#[inline(always)]
pub fn ffa13(&mut self) -> _FFA13W {
_FFA13W { w: self }
}
#[doc = "Bit 14 - Filter FIFO assignment for filter 14"]
#[inline(always)]
pub fn ffa14(&mut self) -> _FFA14W {
_FFA14W { w: self }
}
#[doc = "Bit 15 - Filter FIFO assignment for filter 15"]
#[inline(always)]
pub fn ffa15(&mut self) -> _FFA15W {
_FFA15W { w: self }
}
#[doc = "Bit 16 - Filter FIFO assignment for filter 16"]
#[inline(always)]
pub fn ffa16(&mut self) -> _FFA16W {
_FFA16W { w: self }
}
#[doc = "Bit 17 - Filter FIFO assignment for filter 17"]
#[inline(always)]
pub fn ffa17(&mut self) -> _FFA17W {
_FFA17W { w: self }
}
#[doc = "Bit 18 - Filter FIFO assignment for filter 18"]
#[inline(always)]
pub fn ffa18(&mut self) -> _FFA18W {
_FFA18W { w: self }
}
#[doc = "Bit 19 - Filter FIFO assignment for filter 19"]
#[inline(always)]
pub fn ffa19(&mut self) -> _FFA19W {
_FFA19W { w: self }
}
#[doc = "Bit 20 - Filter FIFO assignment for filter 20"]
#[inline(always)]
pub fn ffa20(&mut self) -> _FFA20W {
_FFA20W { w: self }
}
#[doc = "Bit 21 - Filter FIFO assignment for filter 21"]
#[inline(always)]
pub fn ffa21(&mut self) -> _FFA21W {
_FFA21W { w: self }
}
#[doc = "Bit 22 - Filter FIFO assignment for filter 22"]
#[inline(always)]
pub fn ffa22(&mut self) -> _FFA22W {
_FFA22W { w: self }
}
#[doc = "Bit 23 - Filter FIFO assignment for filter 23"]
#[inline(always)]
pub fn ffa23(&mut self) -> _FFA23W {
_FFA23W { w: self }
}
#[doc = "Bit 24 - Filter FIFO assignment for filter 24"]
#[inline(always)]
pub fn ffa24(&mut self) -> _FFA24W {
_FFA24W { w: self }
}
#[doc = "Bit 25 - Filter FIFO assignment for filter 25"]
#[inline(always)]
pub fn ffa25(&mut self) -> _FFA25W {
_FFA25W { w: self }
}
#[doc = "Bit 26 - Filter FIFO assignment for filter 26"]
#[inline(always)]
pub fn ffa26(&mut self) -> _FFA26W {
_FFA26W { w: self }
}
#[doc = "Bit 27 - Filter FIFO assignment for filter 27"]
#[inline(always)]
pub fn ffa27(&mut self) -> _FFA27W {
_FFA27W { w: self }
}
}