rsl10_pac/sysctrl/
sysctrl_dss_cmd.rs

1#[doc = "Reader of register SYSCTRL_DSS_CMD"]
2pub type R = crate::R<u32, super::SYSCTRL_DSS_CMD>;
3#[doc = "Writer for register SYSCTRL_DSS_CMD"]
4pub type W = crate::W<u32, super::SYSCTRL_DSS_CMD>;
5#[doc = "Register SYSCTRL_DSS_CMD `reset()`'s with value 0"]
6impl crate::ResetValue for super::SYSCTRL_DSS_CMD {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "Write a 1 to issue DSS command 6\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum DSS_CMD_6_AW {
16    #[doc = "1: `1`"]
17    DSS_CMD_6 = 1,
18}
19impl From<DSS_CMD_6_AW> for bool {
20    #[inline(always)]
21    fn from(variant: DSS_CMD_6_AW) -> Self {
22        variant as u8 != 0
23    }
24}
25#[doc = "Write proxy for field `DSS_CMD_6`"]
26pub struct DSS_CMD_6_W<'a> {
27    w: &'a mut W,
28}
29impl<'a> DSS_CMD_6_W<'a> {
30    #[doc = r"Writes `variant` to the field"]
31    #[inline(always)]
32    pub fn variant(self, variant: DSS_CMD_6_AW) -> &'a mut W {
33        {
34            self.bit(variant.into())
35        }
36    }
37    #[doc = "`1`"]
38    #[inline(always)]
39    pub fn dss_cmd_6(self) -> &'a mut W {
40        self.variant(DSS_CMD_6_AW::DSS_CMD_6)
41    }
42    #[doc = r"Sets the field bit"]
43    #[inline(always)]
44    pub fn set_bit(self) -> &'a mut W {
45        self.bit(true)
46    }
47    #[doc = r"Clears the field bit"]
48    #[inline(always)]
49    pub fn clear_bit(self) -> &'a mut W {
50        self.bit(false)
51    }
52    #[doc = r"Writes raw bits to the field"]
53    #[inline(always)]
54    pub fn bit(self, value: bool) -> &'a mut W {
55        self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
56        self.w
57    }
58}
59#[doc = "Write a 1 to issue DSS command 5\n\nValue on reset: 0"]
60#[derive(Clone, Copy, Debug, PartialEq)]
61pub enum DSS_CMD_5_AW {
62    #[doc = "1: `1`"]
63    DSS_CMD_5 = 1,
64}
65impl From<DSS_CMD_5_AW> for bool {
66    #[inline(always)]
67    fn from(variant: DSS_CMD_5_AW) -> Self {
68        variant as u8 != 0
69    }
70}
71#[doc = "Write proxy for field `DSS_CMD_5`"]
72pub struct DSS_CMD_5_W<'a> {
73    w: &'a mut W,
74}
75impl<'a> DSS_CMD_5_W<'a> {
76    #[doc = r"Writes `variant` to the field"]
77    #[inline(always)]
78    pub fn variant(self, variant: DSS_CMD_5_AW) -> &'a mut W {
79        {
80            self.bit(variant.into())
81        }
82    }
83    #[doc = "`1`"]
84    #[inline(always)]
85    pub fn dss_cmd_5(self) -> &'a mut W {
86        self.variant(DSS_CMD_5_AW::DSS_CMD_5)
87    }
88    #[doc = r"Sets the field bit"]
89    #[inline(always)]
90    pub fn set_bit(self) -> &'a mut W {
91        self.bit(true)
92    }
93    #[doc = r"Clears the field bit"]
94    #[inline(always)]
95    pub fn clear_bit(self) -> &'a mut W {
96        self.bit(false)
97    }
98    #[doc = r"Writes raw bits to the field"]
99    #[inline(always)]
100    pub fn bit(self, value: bool) -> &'a mut W {
101        self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
102        self.w
103    }
104}
105#[doc = "Write a 1 to issue DSS command 4\n\nValue on reset: 0"]
106#[derive(Clone, Copy, Debug, PartialEq)]
107pub enum DSS_CMD_4_AW {
108    #[doc = "1: `1`"]
109    DSS_CMD_4 = 1,
110}
111impl From<DSS_CMD_4_AW> for bool {
112    #[inline(always)]
113    fn from(variant: DSS_CMD_4_AW) -> Self {
114        variant as u8 != 0
115    }
116}
117#[doc = "Write proxy for field `DSS_CMD_4`"]
118pub struct DSS_CMD_4_W<'a> {
119    w: &'a mut W,
120}
121impl<'a> DSS_CMD_4_W<'a> {
122    #[doc = r"Writes `variant` to the field"]
123    #[inline(always)]
124    pub fn variant(self, variant: DSS_CMD_4_AW) -> &'a mut W {
125        {
126            self.bit(variant.into())
127        }
128    }
129    #[doc = "`1`"]
130    #[inline(always)]
131    pub fn dss_cmd_4(self) -> &'a mut W {
132        self.variant(DSS_CMD_4_AW::DSS_CMD_4)
133    }
134    #[doc = r"Sets the field bit"]
135    #[inline(always)]
136    pub fn set_bit(self) -> &'a mut W {
137        self.bit(true)
138    }
139    #[doc = r"Clears the field bit"]
140    #[inline(always)]
141    pub fn clear_bit(self) -> &'a mut W {
142        self.bit(false)
143    }
144    #[doc = r"Writes raw bits to the field"]
145    #[inline(always)]
146    pub fn bit(self, value: bool) -> &'a mut W {
147        self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
148        self.w
149    }
150}
151#[doc = "Write a 1 to issue DSS command 3\n\nValue on reset: 0"]
152#[derive(Clone, Copy, Debug, PartialEq)]
153pub enum DSS_CMD_3_AW {
154    #[doc = "1: `1`"]
155    DSS_CMD_3 = 1,
156}
157impl From<DSS_CMD_3_AW> for bool {
158    #[inline(always)]
159    fn from(variant: DSS_CMD_3_AW) -> Self {
160        variant as u8 != 0
161    }
162}
163#[doc = "Write proxy for field `DSS_CMD_3`"]
164pub struct DSS_CMD_3_W<'a> {
165    w: &'a mut W,
166}
167impl<'a> DSS_CMD_3_W<'a> {
168    #[doc = r"Writes `variant` to the field"]
169    #[inline(always)]
170    pub fn variant(self, variant: DSS_CMD_3_AW) -> &'a mut W {
171        {
172            self.bit(variant.into())
173        }
174    }
175    #[doc = "`1`"]
176    #[inline(always)]
177    pub fn dss_cmd_3(self) -> &'a mut W {
178        self.variant(DSS_CMD_3_AW::DSS_CMD_3)
179    }
180    #[doc = r"Sets the field bit"]
181    #[inline(always)]
182    pub fn set_bit(self) -> &'a mut W {
183        self.bit(true)
184    }
185    #[doc = r"Clears the field bit"]
186    #[inline(always)]
187    pub fn clear_bit(self) -> &'a mut W {
188        self.bit(false)
189    }
190    #[doc = r"Writes raw bits to the field"]
191    #[inline(always)]
192    pub fn bit(self, value: bool) -> &'a mut W {
193        self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
194        self.w
195    }
196}
197#[doc = "Write a 1 to issue DSS command 2\n\nValue on reset: 0"]
198#[derive(Clone, Copy, Debug, PartialEq)]
199pub enum DSS_CMD_2_AW {
200    #[doc = "1: `1`"]
201    DSS_CMD_2 = 1,
202}
203impl From<DSS_CMD_2_AW> for bool {
204    #[inline(always)]
205    fn from(variant: DSS_CMD_2_AW) -> Self {
206        variant as u8 != 0
207    }
208}
209#[doc = "Write proxy for field `DSS_CMD_2`"]
210pub struct DSS_CMD_2_W<'a> {
211    w: &'a mut W,
212}
213impl<'a> DSS_CMD_2_W<'a> {
214    #[doc = r"Writes `variant` to the field"]
215    #[inline(always)]
216    pub fn variant(self, variant: DSS_CMD_2_AW) -> &'a mut W {
217        {
218            self.bit(variant.into())
219        }
220    }
221    #[doc = "`1`"]
222    #[inline(always)]
223    pub fn dss_cmd_2(self) -> &'a mut W {
224        self.variant(DSS_CMD_2_AW::DSS_CMD_2)
225    }
226    #[doc = r"Sets the field bit"]
227    #[inline(always)]
228    pub fn set_bit(self) -> &'a mut W {
229        self.bit(true)
230    }
231    #[doc = r"Clears the field bit"]
232    #[inline(always)]
233    pub fn clear_bit(self) -> &'a mut W {
234        self.bit(false)
235    }
236    #[doc = r"Writes raw bits to the field"]
237    #[inline(always)]
238    pub fn bit(self, value: bool) -> &'a mut W {
239        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
240        self.w
241    }
242}
243#[doc = "Write a 1 to issue DSS command 1\n\nValue on reset: 0"]
244#[derive(Clone, Copy, Debug, PartialEq)]
245pub enum DSS_CMD_1_AW {
246    #[doc = "1: `1`"]
247    DSS_CMD_1 = 1,
248}
249impl From<DSS_CMD_1_AW> for bool {
250    #[inline(always)]
251    fn from(variant: DSS_CMD_1_AW) -> Self {
252        variant as u8 != 0
253    }
254}
255#[doc = "Write proxy for field `DSS_CMD_1`"]
256pub struct DSS_CMD_1_W<'a> {
257    w: &'a mut W,
258}
259impl<'a> DSS_CMD_1_W<'a> {
260    #[doc = r"Writes `variant` to the field"]
261    #[inline(always)]
262    pub fn variant(self, variant: DSS_CMD_1_AW) -> &'a mut W {
263        {
264            self.bit(variant.into())
265        }
266    }
267    #[doc = "`1`"]
268    #[inline(always)]
269    pub fn dss_cmd_1(self) -> &'a mut W {
270        self.variant(DSS_CMD_1_AW::DSS_CMD_1)
271    }
272    #[doc = r"Sets the field bit"]
273    #[inline(always)]
274    pub fn set_bit(self) -> &'a mut W {
275        self.bit(true)
276    }
277    #[doc = r"Clears the field bit"]
278    #[inline(always)]
279    pub fn clear_bit(self) -> &'a mut W {
280        self.bit(false)
281    }
282    #[doc = r"Writes raw bits to the field"]
283    #[inline(always)]
284    pub fn bit(self, value: bool) -> &'a mut W {
285        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
286        self.w
287    }
288}
289#[doc = "Write a 1 to issue DSS command 0\n\nValue on reset: 0"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum DSS_CMD_0_AW {
292    #[doc = "1: `1`"]
293    DSS_CMD_0 = 1,
294}
295impl From<DSS_CMD_0_AW> for bool {
296    #[inline(always)]
297    fn from(variant: DSS_CMD_0_AW) -> Self {
298        variant as u8 != 0
299    }
300}
301#[doc = "Write proxy for field `DSS_CMD_0`"]
302pub struct DSS_CMD_0_W<'a> {
303    w: &'a mut W,
304}
305impl<'a> DSS_CMD_0_W<'a> {
306    #[doc = r"Writes `variant` to the field"]
307    #[inline(always)]
308    pub fn variant(self, variant: DSS_CMD_0_AW) -> &'a mut W {
309        {
310            self.bit(variant.into())
311        }
312    }
313    #[doc = "`1`"]
314    #[inline(always)]
315    pub fn dss_cmd_0(self) -> &'a mut W {
316        self.variant(DSS_CMD_0_AW::DSS_CMD_0)
317    }
318    #[doc = r"Sets the field bit"]
319    #[inline(always)]
320    pub fn set_bit(self) -> &'a mut W {
321        self.bit(true)
322    }
323    #[doc = r"Clears the field bit"]
324    #[inline(always)]
325    pub fn clear_bit(self) -> &'a mut W {
326        self.bit(false)
327    }
328    #[doc = r"Writes raw bits to the field"]
329    #[inline(always)]
330    pub fn bit(self, value: bool) -> &'a mut W {
331        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
332        self.w
333    }
334}
335impl R {}
336impl W {
337    #[doc = "Bit 6 - Write a 1 to issue DSS command 6"]
338    #[inline(always)]
339    pub fn dss_cmd_6(&mut self) -> DSS_CMD_6_W {
340        DSS_CMD_6_W { w: self }
341    }
342    #[doc = "Bit 5 - Write a 1 to issue DSS command 5"]
343    #[inline(always)]
344    pub fn dss_cmd_5(&mut self) -> DSS_CMD_5_W {
345        DSS_CMD_5_W { w: self }
346    }
347    #[doc = "Bit 4 - Write a 1 to issue DSS command 4"]
348    #[inline(always)]
349    pub fn dss_cmd_4(&mut self) -> DSS_CMD_4_W {
350        DSS_CMD_4_W { w: self }
351    }
352    #[doc = "Bit 3 - Write a 1 to issue DSS command 3"]
353    #[inline(always)]
354    pub fn dss_cmd_3(&mut self) -> DSS_CMD_3_W {
355        DSS_CMD_3_W { w: self }
356    }
357    #[doc = "Bit 2 - Write a 1 to issue DSS command 2"]
358    #[inline(always)]
359    pub fn dss_cmd_2(&mut self) -> DSS_CMD_2_W {
360        DSS_CMD_2_W { w: self }
361    }
362    #[doc = "Bit 1 - Write a 1 to issue DSS command 1"]
363    #[inline(always)]
364    pub fn dss_cmd_1(&mut self) -> DSS_CMD_1_W {
365        DSS_CMD_1_W { w: self }
366    }
367    #[doc = "Bit 0 - Write a 1 to issue DSS command 0"]
368    #[inline(always)]
369    pub fn dss_cmd_0(&mut self) -> DSS_CMD_0_W {
370        DSS_CMD_0_W { w: self }
371    }
372}
rsl10_pac/sysctrl/sysctrl_dss_cmd.rs

rsl10_pac/sysctrl/
sysctrl_dss_cmd.rs
