rsl10_pac/sysctrl/
sysctrl_rf_access_cfg.rs

1#[doc = "Reader of register SYSCTRL_RF_ACCESS_CFG"]
2pub type R = crate::R<u32, super::SYSCTRL_RF_ACCESS_CFG>;
3#[doc = "Writer for register SYSCTRL_RF_ACCESS_CFG"]
4pub type W = crate::W<u32, super::SYSCTRL_RF_ACCESS_CFG>;
5#[doc = "Register SYSCTRL_RF_ACCESS_CFG `reset()`'s with value 0"]
6impl crate::ResetValue for super::SYSCTRL_RF_ACCESS_CFG {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "RF IRQ access configuration\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum RF_IRQ_ACCESS_A {
16    #[doc = "0: RF IRQ access disabled"]
17    RF_IRQ_ACCESS_DISABLE = 0,
18    #[doc = "1: RF IRQ access enabled"]
19    RF_IRQ_ACCESS_ENABLE = 1,
20}
21impl From<RF_IRQ_ACCESS_A> for bool {
22    #[inline(always)]
23    fn from(variant: RF_IRQ_ACCESS_A) -> Self {
24        variant as u8 != 0
25    }
26}
27#[doc = "Reader of field `RF_IRQ_ACCESS`"]
28pub type RF_IRQ_ACCESS_R = crate::R<bool, RF_IRQ_ACCESS_A>;
29impl RF_IRQ_ACCESS_R {
30    #[doc = r"Get enumerated values variant"]
31    #[inline(always)]
32    pub fn variant(&self) -> RF_IRQ_ACCESS_A {
33        match self.bits {
34            false => RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_DISABLE,
35            true => RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_ENABLE,
36        }
37    }
38    #[doc = "Checks if the value of the field is `RF_IRQ_ACCESS_DISABLE`"]
39    #[inline(always)]
40    pub fn is_rf_irq_access_disable(&self) -> bool {
41        *self == RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_DISABLE
42    }
43    #[doc = "Checks if the value of the field is `RF_IRQ_ACCESS_ENABLE`"]
44    #[inline(always)]
45    pub fn is_rf_irq_access_enable(&self) -> bool {
46        *self == RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_ENABLE
47    }
48}
49#[doc = "Write proxy for field `RF_IRQ_ACCESS`"]
50pub struct RF_IRQ_ACCESS_W<'a> {
51    w: &'a mut W,
52}
53impl<'a> RF_IRQ_ACCESS_W<'a> {
54    #[doc = r"Writes `variant` to the field"]
55    #[inline(always)]
56    pub fn variant(self, variant: RF_IRQ_ACCESS_A) -> &'a mut W {
57        {
58            self.bit(variant.into())
59        }
60    }
61    #[doc = "RF IRQ access disabled"]
62    #[inline(always)]
63    pub fn rf_irq_access_disable(self) -> &'a mut W {
64        self.variant(RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_DISABLE)
65    }
66    #[doc = "RF IRQ access enabled"]
67    #[inline(always)]
68    pub fn rf_irq_access_enable(self) -> &'a mut W {
69        self.variant(RF_IRQ_ACCESS_A::RF_IRQ_ACCESS_ENABLE)
70    }
71    #[doc = r"Sets the field bit"]
72    #[inline(always)]
73    pub fn set_bit(self) -> &'a mut W {
74        self.bit(true)
75    }
76    #[doc = r"Clears the field bit"]
77    #[inline(always)]
78    pub fn clear_bit(self) -> &'a mut W {
79        self.bit(false)
80    }
81    #[doc = r"Writes raw bits to the field"]
82    #[inline(always)]
83    pub fn bit(self, value: bool) -> &'a mut W {
84        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
85        self.w
86    }
87}
88#[doc = "RF access configuration\n\nValue on reset: 0"]
89#[derive(Clone, Copy, Debug, PartialEq)]
90pub enum RF_ACCESS_A {
91    #[doc = "0: RF access disabled"]
92    RF_ACCESS_DISABLE = 0,
93    #[doc = "1: RF access enabled"]
94    RF_ACCESS_ENABLE = 1,
95}
96impl From<RF_ACCESS_A> for bool {
97    #[inline(always)]
98    fn from(variant: RF_ACCESS_A) -> Self {
99        variant as u8 != 0
100    }
101}
102#[doc = "Reader of field `RF_ACCESS`"]
103pub type RF_ACCESS_R = crate::R<bool, RF_ACCESS_A>;
104impl RF_ACCESS_R {
105    #[doc = r"Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> RF_ACCESS_A {
108        match self.bits {
109            false => RF_ACCESS_A::RF_ACCESS_DISABLE,
110            true => RF_ACCESS_A::RF_ACCESS_ENABLE,
111        }
112    }
113    #[doc = "Checks if the value of the field is `RF_ACCESS_DISABLE`"]
114    #[inline(always)]
115    pub fn is_rf_access_disable(&self) -> bool {
116        *self == RF_ACCESS_A::RF_ACCESS_DISABLE
117    }
118    #[doc = "Checks if the value of the field is `RF_ACCESS_ENABLE`"]
119    #[inline(always)]
120    pub fn is_rf_access_enable(&self) -> bool {
121        *self == RF_ACCESS_A::RF_ACCESS_ENABLE
122    }
123}
124#[doc = "Write proxy for field `RF_ACCESS`"]
125pub struct RF_ACCESS_W<'a> {
126    w: &'a mut W,
127}
128impl<'a> RF_ACCESS_W<'a> {
129    #[doc = r"Writes `variant` to the field"]
130    #[inline(always)]
131    pub fn variant(self, variant: RF_ACCESS_A) -> &'a mut W {
132        {
133            self.bit(variant.into())
134        }
135    }
136    #[doc = "RF access disabled"]
137    #[inline(always)]
138    pub fn rf_access_disable(self) -> &'a mut W {
139        self.variant(RF_ACCESS_A::RF_ACCESS_DISABLE)
140    }
141    #[doc = "RF access enabled"]
142    #[inline(always)]
143    pub fn rf_access_enable(self) -> &'a mut W {
144        self.variant(RF_ACCESS_A::RF_ACCESS_ENABLE)
145    }
146    #[doc = r"Sets the field bit"]
147    #[inline(always)]
148    pub fn set_bit(self) -> &'a mut W {
149        self.bit(true)
150    }
151    #[doc = r"Clears the field bit"]
152    #[inline(always)]
153    pub fn clear_bit(self) -> &'a mut W {
154        self.bit(false)
155    }
156    #[doc = r"Writes raw bits to the field"]
157    #[inline(always)]
158    pub fn bit(self, value: bool) -> &'a mut W {
159        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
160        self.w
161    }
162}
163impl R {
164    #[doc = "Bit 1 - RF IRQ access configuration"]
165    #[inline(always)]
166    pub fn rf_irq_access(&self) -> RF_IRQ_ACCESS_R {
167        RF_IRQ_ACCESS_R::new(((self.bits >> 1) & 0x01) != 0)
168    }
169    #[doc = "Bit 0 - RF access configuration"]
170    #[inline(always)]
171    pub fn rf_access(&self) -> RF_ACCESS_R {
172        RF_ACCESS_R::new((self.bits & 0x01) != 0)
173    }
174}
175impl W {
176    #[doc = "Bit 1 - RF IRQ access configuration"]
177    #[inline(always)]
178    pub fn rf_irq_access(&mut self) -> RF_IRQ_ACCESS_W {
179        RF_IRQ_ACCESS_W { w: self }
180    }
181    #[doc = "Bit 0 - RF access configuration"]
182    #[inline(always)]
183    pub fn rf_access(&mut self) -> RF_ACCESS_W {
184        RF_ACCESS_W { w: self }
185    }
186}
rsl10_pac/sysctrl/sysctrl_rf_access_cfg.rs

rsl10_pac/sysctrl/
sysctrl_rf_access_cfg.rs
