nrf9160_pac/nvmc_ns/
config.rs

1#[doc = "Register `CONFIG` reader"]
2pub struct R(crate::R<CONFIG_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<CONFIG_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<CONFIG_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<CONFIG_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `CONFIG` writer"]
17pub struct W(crate::W<CONFIG_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<CONFIG_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<CONFIG_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<CONFIG_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `WEN` reader - Program memory access mode. It is strongly recommended to only activate erase and write modes when they are actively used. Enabling write or erase will invalidate the cache and keep it invalidated."]
38pub type WEN_R = crate::FieldReader<u8, WEN_A>;
39#[doc = "Program memory access mode. It is strongly recommended to only activate erase and write modes when they are actively used. Enabling write or erase will invalidate the cache and keep it invalidated.\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41#[repr(u8)]
42pub enum WEN_A {
43    #[doc = "0: Read only access"]
44    REN = 0,
45    #[doc = "1: Write enabled"]
46    WEN = 1,
47    #[doc = "2: Erase enabled"]
48    EEN = 2,
49    #[doc = "4: Partial erase enabled"]
50    PEEN = 4,
51}
52impl From<WEN_A> for u8 {
53    #[inline(always)]
54    fn from(variant: WEN_A) -> Self {
55        variant as _
56    }
57}
58impl WEN_R {
59    #[doc = "Get enumerated values variant"]
60    #[inline(always)]
61    pub fn variant(&self) -> Option<WEN_A> {
62        match self.bits {
63            0 => Some(WEN_A::REN),
64            1 => Some(WEN_A::WEN),
65            2 => Some(WEN_A::EEN),
66            4 => Some(WEN_A::PEEN),
67            _ => None,
68        }
69    }
70    #[doc = "Checks if the value of the field is `REN`"]
71    #[inline(always)]
72    pub fn is_ren(&self) -> bool {
73        *self == WEN_A::REN
74    }
75    #[doc = "Checks if the value of the field is `WEN`"]
76    #[inline(always)]
77    pub fn is_wen(&self) -> bool {
78        *self == WEN_A::WEN
79    }
80    #[doc = "Checks if the value of the field is `EEN`"]
81    #[inline(always)]
82    pub fn is_een(&self) -> bool {
83        *self == WEN_A::EEN
84    }
85    #[doc = "Checks if the value of the field is `PEEN`"]
86    #[inline(always)]
87    pub fn is_peen(&self) -> bool {
88        *self == WEN_A::PEEN
89    }
90}
91#[doc = "Field `WEN` writer - Program memory access mode. It is strongly recommended to only activate erase and write modes when they are actively used. Enabling write or erase will invalidate the cache and keep it invalidated."]
92pub type WEN_W<'a, const O: u8> = crate::FieldWriter<'a, u32, CONFIG_SPEC, u8, WEN_A, 3, O>;
93impl<'a, const O: u8> WEN_W<'a, O> {
94    #[doc = "Read only access"]
95    #[inline(always)]
96    pub fn ren(self) -> &'a mut W {
97        self.variant(WEN_A::REN)
98    }
99    #[doc = "Write enabled"]
100    #[inline(always)]
101    pub fn wen(self) -> &'a mut W {
102        self.variant(WEN_A::WEN)
103    }
104    #[doc = "Erase enabled"]
105    #[inline(always)]
106    pub fn een(self) -> &'a mut W {
107        self.variant(WEN_A::EEN)
108    }
109    #[doc = "Partial erase enabled"]
110    #[inline(always)]
111    pub fn peen(self) -> &'a mut W {
112        self.variant(WEN_A::PEEN)
113    }
114}
115impl R {
116    #[doc = "Bits 0:2 - Program memory access mode. It is strongly recommended to only activate erase and write modes when they are actively used. Enabling write or erase will invalidate the cache and keep it invalidated."]
117    #[inline(always)]
118    pub fn wen(&self) -> WEN_R {
119        WEN_R::new((self.bits & 7) as u8)
120    }
121}
122impl W {
123    #[doc = "Bits 0:2 - Program memory access mode. It is strongly recommended to only activate erase and write modes when they are actively used. Enabling write or erase will invalidate the cache and keep it invalidated."]
124    #[inline(always)]
125    pub fn wen(&mut self) -> WEN_W<0> {
126        WEN_W::new(self)
127    }
128    #[doc = "Writes raw bits to the register."]
129    #[inline(always)]
130    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
131        self.0.bits(bits);
132        self
133    }
134}
135#[doc = "Configuration register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [config](index.html) module"]
136pub struct CONFIG_SPEC;
137impl crate::RegisterSpec for CONFIG_SPEC {
138    type Ux = u32;
139}
140#[doc = "`read()` method returns [config::R](R) reader structure"]
141impl crate::Readable for CONFIG_SPEC {
142    type Reader = R;
143}
144#[doc = "`write(|w| ..)` method takes [config::W](W) writer structure"]
145impl crate::Writable for CONFIG_SPEC {
146    type Writer = W;
147}
148#[doc = "`reset()` method sets CONFIG to value 0"]
149impl crate::Resettable for CONFIG_SPEC {
150    #[inline(always)]
151    fn reset_value() -> Self::Ux {
152        0
153    }
154}