#[doc = "Register `sgi_auto_mode` reader"]
pub type R = crate::R<SgiAutoModeSpec>;
#[doc = "Register `sgi_auto_mode` writer"]
pub type W = crate::W<SgiAutoModeSpec>;
#[doc = "Field `auto_mode_en` reader - auto_start_en"]
pub type AutoModeEnR = crate::BitReader;
#[doc = "Field `auto_mode_en` writer - auto_start_en"]
pub type AutoModeEnW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `auto_mode_stop` writer - auto_mode_stop"]
pub type AutoModeStopW<'a, REG> = crate::BitWriter<'a, REG>;
#[doc = "Field `auto_mode_rsvd1` reader - reserved"]
pub type AutoModeRsvd1R = crate::FieldReader;
#[doc = "Field `incr_mode` reader - CTR increment mode"]
pub type IncrModeR = crate::FieldReader;
#[doc = "Field `incr_mode` writer - CTR increment mode"]
pub type IncrModeW<'a, REG> = crate::FieldWriter<'a, REG, 2>;
#[doc = "Field `auto_mode_rsvd2` reader - reserved"]
pub type AutoModeRsvd2R = crate::FieldReader;
#[doc = "Auto mode of operation\n\nValue on reset: 0"]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum Cmd {
#[doc = "0: 8'h00 - ECB mode"]
Ecb = 0,
#[doc = "1: 8'h01 - CTR mode"]
Ctr = 1,
#[doc = "2: 8'h02 - CBC mode"]
Cbc = 2,
#[doc = "3: 8'h03 - CBCMAC mode"]
Cbcmac = 3,
#[doc = "16: 8'h10 - Key Wrap/Unwrap(128 bit key data)"]
Kw128 = 16,
#[doc = "17: 8'h11 - Key Wrap/Unwrap(256 bit key data)"]
Kw256 = 17,
}
impl From<Cmd> for u8 {
#[inline(always)]
fn from(variant: Cmd) -> Self {
variant as _
}
}
impl crate::FieldSpec for Cmd {
type Ux = u8;
}
impl crate::IsEnum for Cmd {}
#[doc = "Field `cmd` reader - Auto mode of operation"]
pub type CmdR = crate::FieldReader<Cmd>;
impl CmdR {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub const fn variant(&self) -> Option<Cmd> {
match self.bits {
0 => Some(Cmd::Ecb),
1 => Some(Cmd::Ctr),
2 => Some(Cmd::Cbc),
3 => Some(Cmd::Cbcmac),
16 => Some(Cmd::Kw128),
17 => Some(Cmd::Kw256),
_ => None,
}
}
#[doc = "8'h00 - ECB mode"]
#[inline(always)]
pub fn is_ecb(&self) -> bool {
*self == Cmd::Ecb
}
#[doc = "8'h01 - CTR mode"]
#[inline(always)]
pub fn is_ctr(&self) -> bool {
*self == Cmd::Ctr
}
#[doc = "8'h02 - CBC mode"]
#[inline(always)]
pub fn is_cbc(&self) -> bool {
*self == Cmd::Cbc
}
#[doc = "8'h03 - CBCMAC mode"]
#[inline(always)]
pub fn is_cbcmac(&self) -> bool {
*self == Cmd::Cbcmac
}
#[doc = "8'h10 - Key Wrap/Unwrap(128 bit key data)"]
#[inline(always)]
pub fn is_kw128(&self) -> bool {
*self == Cmd::Kw128
}
#[doc = "8'h11 - Key Wrap/Unwrap(256 bit key data)"]
#[inline(always)]
pub fn is_kw256(&self) -> bool {
*self == Cmd::Kw256
}
}
#[doc = "Field `cmd` writer - Auto mode of operation"]
pub type CmdW<'a, REG> = crate::FieldWriter<'a, REG, 8, Cmd>;
impl<'a, REG> CmdW<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
REG::Ux: From<u8>,
{
#[doc = "8'h00 - ECB mode"]
#[inline(always)]
pub fn ecb(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Ecb)
}
#[doc = "8'h01 - CTR mode"]
#[inline(always)]
pub fn ctr(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Ctr)
}
#[doc = "8'h02 - CBC mode"]
#[inline(always)]
pub fn cbc(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Cbc)
}
#[doc = "8'h03 - CBCMAC mode"]
#[inline(always)]
pub fn cbcmac(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Cbcmac)
}
#[doc = "8'h10 - Key Wrap/Unwrap(128 bit key data)"]
#[inline(always)]
pub fn kw128(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Kw128)
}
#[doc = "8'h11 - Key Wrap/Unwrap(256 bit key data)"]
#[inline(always)]
pub fn kw256(self) -> &'a mut crate::W<REG> {
self.variant(Cmd::Kw256)
}
}
#[doc = "Field `auto_mode_rsvd3` reader - reserved"]
pub type AutoModeRsvd3R = crate::FieldReader<u16>;
impl R {
#[doc = "Bit 0 - auto_start_en"]
#[inline(always)]
pub fn auto_mode_en(&self) -> AutoModeEnR {
AutoModeEnR::new((self.bits & 1) != 0)
}
#[doc = "Bits 2:3 - reserved"]
#[inline(always)]
pub fn auto_mode_rsvd1(&self) -> AutoModeRsvd1R {
AutoModeRsvd1R::new(((self.bits >> 2) & 3) as u8)
}
#[doc = "Bits 4:5 - CTR increment mode"]
#[inline(always)]
pub fn incr_mode(&self) -> IncrModeR {
IncrModeR::new(((self.bits >> 4) & 3) as u8)
}
#[doc = "Bits 6:7 - reserved"]
#[inline(always)]
pub fn auto_mode_rsvd2(&self) -> AutoModeRsvd2R {
AutoModeRsvd2R::new(((self.bits >> 6) & 3) as u8)
}
#[doc = "Bits 8:15 - Auto mode of operation"]
#[inline(always)]
pub fn cmd(&self) -> CmdR {
CmdR::new(((self.bits >> 8) & 0xff) as u8)
}
#[doc = "Bits 16:31 - reserved"]
#[inline(always)]
pub fn auto_mode_rsvd3(&self) -> AutoModeRsvd3R {
AutoModeRsvd3R::new(((self.bits >> 16) & 0xffff) as u16)
}
}
#[cfg(feature = "debug")]
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("sgi_auto_mode")
.field("auto_mode_en", &self.auto_mode_en())
.field("auto_mode_rsvd1", &self.auto_mode_rsvd1())
.field("incr_mode", &self.incr_mode())
.field("auto_mode_rsvd2", &self.auto_mode_rsvd2())
.field("cmd", &self.cmd())
.field("auto_mode_rsvd3", &self.auto_mode_rsvd3())
.finish()
}
}
impl W {
#[doc = "Bit 0 - auto_start_en"]
#[inline(always)]
pub fn auto_mode_en(&mut self) -> AutoModeEnW<'_, SgiAutoModeSpec> {
AutoModeEnW::new(self, 0)
}
#[doc = "Bit 1 - auto_mode_stop"]
#[inline(always)]
pub fn auto_mode_stop(&mut self) -> AutoModeStopW<'_, SgiAutoModeSpec> {
AutoModeStopW::new(self, 1)
}
#[doc = "Bits 4:5 - CTR increment mode"]
#[inline(always)]
pub fn incr_mode(&mut self) -> IncrModeW<'_, SgiAutoModeSpec> {
IncrModeW::new(self, 4)
}
#[doc = "Bits 8:15 - Auto mode of operation"]
#[inline(always)]
pub fn cmd(&mut self) -> CmdW<'_, SgiAutoModeSpec> {
CmdW::new(self, 8)
}
}
#[doc = "SGI Auto Mode Control register\n\nYou can [`read`](crate::Reg::read) this register and get [`sgi_auto_mode::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`sgi_auto_mode::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct SgiAutoModeSpec;
impl crate::RegisterSpec for SgiAutoModeSpec {
type Ux = u32;
}
#[doc = "`read()` method returns [`sgi_auto_mode::R`](R) reader structure"]
impl crate::Readable for SgiAutoModeSpec {}
#[doc = "`write(|w| ..)` method takes [`sgi_auto_mode::W`](W) writer structure"]
impl crate::Writable for SgiAutoModeSpec {
type Safety = crate::Unsafe;
}
#[doc = "`reset()` method sets sgi_auto_mode to value 0"]
impl crate::Resettable for SgiAutoModeSpec {}