#[doc = "Reader of register CTL"]
pub type R = crate::R<u32, super::CTL>;
#[doc = "Writer for register CTL"]
pub type W = crate::W<u32, super::CTL>;
#[doc = "Register CTL `reset()`'s with value 0x1000_0000"]
impl crate::ResetValue for super::CTL {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x1000_0000
}
}
#[doc = "CRC Peripheral Enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum EN_A {
#[doc = "0: CRC peripheral is disabled"]
CRC_DIS = 0,
#[doc = "1: CRC peripheral is enabled"]
CRC_EN = 1,
}
impl From<EN_A> for bool {
#[inline(always)]
fn from(variant: EN_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `EN`"]
pub type EN_R = crate::R<bool, EN_A>;
impl EN_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> EN_A {
match self.bits {
false => EN_A::CRC_DIS,
true => EN_A::CRC_EN,
}
}
#[doc = "Checks if the value of the field is `CRC_DIS`"]
#[inline(always)]
pub fn is_crc_dis(&self) -> bool {
*self == EN_A::CRC_DIS
}
#[doc = "Checks if the value of the field is `CRC_EN`"]
#[inline(always)]
pub fn is_crc_en(&self) -> bool {
*self == EN_A::CRC_EN
}
}
#[doc = "Write proxy for field `EN`"]
pub struct EN_W<'a> {
w: &'a mut W,
}
impl<'a> EN_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: EN_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "CRC peripheral is disabled"]
#[inline(always)]
pub fn crc_dis(self) -> &'a mut W {
self.variant(EN_A::CRC_DIS)
}
#[doc = "CRC peripheral is enabled"]
#[inline(always)]
pub fn crc_en(self) -> &'a mut W {
self.variant(EN_A::CRC_EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "LSB First Calculation Order\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LSBFIRST_A {
#[doc = "0: MSB First CRC calculation is done"]
MSB_FIRST = 0,
#[doc = "1: LSB First CRC calculation is done"]
LSB_FIRST = 1,
}
impl From<LSBFIRST_A> for bool {
#[inline(always)]
fn from(variant: LSBFIRST_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `LSBFIRST`"]
pub type LSBFIRST_R = crate::R<bool, LSBFIRST_A>;
impl LSBFIRST_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LSBFIRST_A {
match self.bits {
false => LSBFIRST_A::MSB_FIRST,
true => LSBFIRST_A::LSB_FIRST,
}
}
#[doc = "Checks if the value of the field is `MSB_FIRST`"]
#[inline(always)]
pub fn is_msb_first(&self) -> bool {
*self == LSBFIRST_A::MSB_FIRST
}
#[doc = "Checks if the value of the field is `LSB_FIRST`"]
#[inline(always)]
pub fn is_lsb_first(&self) -> bool {
*self == LSBFIRST_A::LSB_FIRST
}
}
#[doc = "Write proxy for field `LSBFIRST`"]
pub struct LSBFIRST_W<'a> {
w: &'a mut W,
}
impl<'a> LSBFIRST_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: LSBFIRST_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "MSB First CRC calculation is done"]
#[inline(always)]
pub fn msb_first(self) -> &'a mut W {
self.variant(LSBFIRST_A::MSB_FIRST)
}
#[doc = "LSB First CRC calculation is done"]
#[inline(always)]
pub fn lsb_first(self) -> &'a mut W {
self.variant(LSBFIRST_A::LSB_FIRST)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Bit Mirroring\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BITMIRR_A {
#[doc = "0: Bit Mirroring is disabled"]
BITMIRR_DIS = 0,
#[doc = "1: Bit Mirroring is enabled"]
BITMIRR_EN = 1,
}
impl From<BITMIRR_A> for bool {
#[inline(always)]
fn from(variant: BITMIRR_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `BITMIRR`"]
pub type BITMIRR_R = crate::R<bool, BITMIRR_A>;
impl BITMIRR_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BITMIRR_A {
match self.bits {
false => BITMIRR_A::BITMIRR_DIS,
true => BITMIRR_A::BITMIRR_EN,
}
}
#[doc = "Checks if the value of the field is `BITMIRR_DIS`"]
#[inline(always)]
pub fn is_bitmirr_dis(&self) -> bool {
*self == BITMIRR_A::BITMIRR_DIS
}
#[doc = "Checks if the value of the field is `BITMIRR_EN`"]
#[inline(always)]
pub fn is_bitmirr_en(&self) -> bool {
*self == BITMIRR_A::BITMIRR_EN
}
}
#[doc = "Write proxy for field `BITMIRR`"]
pub struct BITMIRR_W<'a> {
w: &'a mut W,
}
impl<'a> BITMIRR_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BITMIRR_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Bit Mirroring is disabled"]
#[inline(always)]
pub fn bitmirr_dis(self) -> &'a mut W {
self.variant(BITMIRR_A::BITMIRR_DIS)
}
#[doc = "Bit Mirroring is enabled"]
#[inline(always)]
pub fn bitmirr_en(self) -> &'a mut W {
self.variant(BITMIRR_A::BITMIRR_EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Byte Mirroring\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BYTMIRR_A {
#[doc = "0: Byte Mirroring is disabled"]
BYTEMIR_DIS = 0,
#[doc = "1: Byte Mirroring is enabled"]
BYTEMIR_EN = 1,
}
impl From<BYTMIRR_A> for bool {
#[inline(always)]
fn from(variant: BYTMIRR_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `BYTMIRR`"]
pub type BYTMIRR_R = crate::R<bool, BYTMIRR_A>;
impl BYTMIRR_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> BYTMIRR_A {
match self.bits {
false => BYTMIRR_A::BYTEMIR_DIS,
true => BYTMIRR_A::BYTEMIR_EN,
}
}
#[doc = "Checks if the value of the field is `BYTEMIR_DIS`"]
#[inline(always)]
pub fn is_bytemir_dis(&self) -> bool {
*self == BYTMIRR_A::BYTEMIR_DIS
}
#[doc = "Checks if the value of the field is `BYTEMIR_EN`"]
#[inline(always)]
pub fn is_bytemir_en(&self) -> bool {
*self == BYTMIRR_A::BYTEMIR_EN
}
}
#[doc = "Write proxy for field `BYTMIRR`"]
pub struct BYTMIRR_W<'a> {
w: &'a mut W,
}
impl<'a> BYTMIRR_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: BYTMIRR_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Byte Mirroring is disabled"]
#[inline(always)]
pub fn bytemir_dis(self) -> &'a mut W {
self.variant(BYTMIRR_A::BYTEMIR_DIS)
}
#[doc = "Byte Mirroring is enabled"]
#[inline(always)]
pub fn bytemir_en(self) -> &'a mut W {
self.variant(BYTMIRR_A::BYTEMIR_EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Word16 Swap\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum W16SWP_A {
#[doc = "0: Word16 Swap disabled"]
W16SP_DIS = 0,
#[doc = "1: Word16 Swap enabled"]
W16SP_EN = 1,
}
impl From<W16SWP_A> for bool {
#[inline(always)]
fn from(variant: W16SWP_A) -> Self {
variant as u8 != 0
}
}
#[doc = "Reader of field `W16SWP`"]
pub type W16SWP_R = crate::R<bool, W16SWP_A>;
impl W16SWP_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> W16SWP_A {
match self.bits {
false => W16SWP_A::W16SP_DIS,
true => W16SWP_A::W16SP_EN,
}
}
#[doc = "Checks if the value of the field is `W16SP_DIS`"]
#[inline(always)]
pub fn is_w16sp_dis(&self) -> bool {
*self == W16SWP_A::W16SP_DIS
}
#[doc = "Checks if the value of the field is `W16SP_EN`"]
#[inline(always)]
pub fn is_w16sp_en(&self) -> bool {
*self == W16SWP_A::W16SP_EN
}
}
#[doc = "Write proxy for field `W16SWP`"]
pub struct W16SWP_W<'a> {
w: &'a mut W,
}
impl<'a> W16SWP_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: W16SWP_A) -> &'a mut W {
{
self.bit(variant.into())
}
}
#[doc = "Word16 Swap disabled"]
#[inline(always)]
pub fn w16sp_dis(self) -> &'a mut W {
self.variant(W16SWP_A::W16SP_DIS)
}
#[doc = "Word16 Swap enabled"]
#[inline(always)]
pub fn w16sp_en(self) -> &'a mut W {
self.variant(W16SWP_A::W16SP_EN)
}
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `RevID`"]
pub type REVID_R = crate::R<u8, u8>;
impl R {
#[doc = "Bit 0 - CRC Peripheral Enable"]
#[inline(always)]
pub fn en(&self) -> EN_R {
EN_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - LSB First Calculation Order"]
#[inline(always)]
pub fn lsbfirst(&self) -> LSBFIRST_R {
LSBFIRST_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Bit Mirroring"]
#[inline(always)]
pub fn bitmirr(&self) -> BITMIRR_R {
BITMIRR_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Byte Mirroring"]
#[inline(always)]
pub fn bytmirr(&self) -> BYTMIRR_R {
BYTMIRR_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Word16 Swap"]
#[inline(always)]
pub fn w16swp(&self) -> W16SWP_R {
W16SWP_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bits 28:31 - Revision ID"]
#[inline(always)]
pub fn rev_id(&self) -> REVID_R {
REVID_R::new(((self.bits >> 28) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bit 0 - CRC Peripheral Enable"]
#[inline(always)]
pub fn en(&mut self) -> EN_W {
EN_W { w: self }
}
#[doc = "Bit 1 - LSB First Calculation Order"]
#[inline(always)]
pub fn lsbfirst(&mut self) -> LSBFIRST_W {
LSBFIRST_W { w: self }
}
#[doc = "Bit 2 - Bit Mirroring"]
#[inline(always)]
pub fn bitmirr(&mut self) -> BITMIRR_W {
BITMIRR_W { w: self }
}
#[doc = "Bit 3 - Byte Mirroring"]
#[inline(always)]
pub fn bytmirr(&mut self) -> BYTMIRR_W {
BYTMIRR_W { w: self }
}
#[doc = "Bit 4 - Word16 Swap"]
#[inline(always)]
pub fn w16swp(&mut self) -> W16SWP_W {
W16SWP_W { w: self }
}
}