1#[doc = "Register `PRCLR0` writer"]
2pub type W = crate::W<PRCLR0_SPEC>;
3#[doc = "VADC Reset Clear\n\nValue on reset: 0"]
4#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5pub enum VADCRS_A {
6 #[doc = "0: No effect"]
7 VALUE1 = 0,
8 #[doc = "1: De-assert reset"]
9 VALUE2 = 1,
10}
11impl From<VADCRS_A> for bool {
12 #[inline(always)]
13 fn from(variant: VADCRS_A) -> Self {
14 variant as u8 != 0
15 }
16}
17#[doc = "Field `VADCRS` writer - VADC Reset Clear"]
18pub type VADCRS_W<'a, REG> = crate::BitWriter<'a, REG, VADCRS_A>;
19impl<'a, REG> VADCRS_W<'a, REG>
20where
21 REG: crate::Writable + crate::RegisterSpec,
22{
23 #[doc = "No effect"]
24 #[inline(always)]
25 pub fn value1(self) -> &'a mut crate::W<REG> {
26 self.variant(VADCRS_A::VALUE1)
27 }
28 #[doc = "De-assert reset"]
29 #[inline(always)]
30 pub fn value2(self) -> &'a mut crate::W<REG> {
31 self.variant(VADCRS_A::VALUE2)
32 }
33}
34#[doc = "DSD Reset Clear\n\nValue on reset: 0"]
35#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub enum DSDRS_A {
37 #[doc = "0: No effect"]
38 VALUE1 = 0,
39 #[doc = "1: De-assert reset"]
40 VALUE2 = 1,
41}
42impl From<DSDRS_A> for bool {
43 #[inline(always)]
44 fn from(variant: DSDRS_A) -> Self {
45 variant as u8 != 0
46 }
47}
48#[doc = "Field `DSDRS` writer - DSD Reset Clear"]
49pub type DSDRS_W<'a, REG> = crate::BitWriter<'a, REG, DSDRS_A>;
50impl<'a, REG> DSDRS_W<'a, REG>
51where
52 REG: crate::Writable + crate::RegisterSpec,
53{
54 #[doc = "No effect"]
55 #[inline(always)]
56 pub fn value1(self) -> &'a mut crate::W<REG> {
57 self.variant(DSDRS_A::VALUE1)
58 }
59 #[doc = "De-assert reset"]
60 #[inline(always)]
61 pub fn value2(self) -> &'a mut crate::W<REG> {
62 self.variant(DSDRS_A::VALUE2)
63 }
64}
65#[doc = "CCU40 Reset Clear\n\nValue on reset: 0"]
66#[derive(Clone, Copy, Debug, PartialEq, Eq)]
67pub enum CCU40RS_A {
68 #[doc = "0: No effect"]
69 VALUE1 = 0,
70 #[doc = "1: De-assert reset"]
71 VALUE2 = 1,
72}
73impl From<CCU40RS_A> for bool {
74 #[inline(always)]
75 fn from(variant: CCU40RS_A) -> Self {
76 variant as u8 != 0
77 }
78}
79#[doc = "Field `CCU40RS` writer - CCU40 Reset Clear"]
80pub type CCU40RS_W<'a, REG> = crate::BitWriter<'a, REG, CCU40RS_A>;
81impl<'a, REG> CCU40RS_W<'a, REG>
82where
83 REG: crate::Writable + crate::RegisterSpec,
84{
85 #[doc = "No effect"]
86 #[inline(always)]
87 pub fn value1(self) -> &'a mut crate::W<REG> {
88 self.variant(CCU40RS_A::VALUE1)
89 }
90 #[doc = "De-assert reset"]
91 #[inline(always)]
92 pub fn value2(self) -> &'a mut crate::W<REG> {
93 self.variant(CCU40RS_A::VALUE2)
94 }
95}
96#[doc = "CCU41 Reset Clear\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq, Eq)]
98pub enum CCU41RS_A {
99 #[doc = "0: No effect"]
100 VALUE1 = 0,
101 #[doc = "1: De-assert reset"]
102 VALUE2 = 1,
103}
104impl From<CCU41RS_A> for bool {
105 #[inline(always)]
106 fn from(variant: CCU41RS_A) -> Self {
107 variant as u8 != 0
108 }
109}
110#[doc = "Field `CCU41RS` writer - CCU41 Reset Clear"]
111pub type CCU41RS_W<'a, REG> = crate::BitWriter<'a, REG, CCU41RS_A>;
112impl<'a, REG> CCU41RS_W<'a, REG>
113where
114 REG: crate::Writable + crate::RegisterSpec,
115{
116 #[doc = "No effect"]
117 #[inline(always)]
118 pub fn value1(self) -> &'a mut crate::W<REG> {
119 self.variant(CCU41RS_A::VALUE1)
120 }
121 #[doc = "De-assert reset"]
122 #[inline(always)]
123 pub fn value2(self) -> &'a mut crate::W<REG> {
124 self.variant(CCU41RS_A::VALUE2)
125 }
126}
127#[doc = "CCU42 Reset Clear\n\nValue on reset: 0"]
128#[derive(Clone, Copy, Debug, PartialEq, Eq)]
129pub enum CCU42RS_A {
130 #[doc = "0: No effect"]
131 VALUE1 = 0,
132 #[doc = "1: De-assert reset"]
133 VALUE2 = 1,
134}
135impl From<CCU42RS_A> for bool {
136 #[inline(always)]
137 fn from(variant: CCU42RS_A) -> Self {
138 variant as u8 != 0
139 }
140}
141#[doc = "Field `CCU42RS` writer - CCU42 Reset Clear"]
142pub type CCU42RS_W<'a, REG> = crate::BitWriter<'a, REG, CCU42RS_A>;
143impl<'a, REG> CCU42RS_W<'a, REG>
144where
145 REG: crate::Writable + crate::RegisterSpec,
146{
147 #[doc = "No effect"]
148 #[inline(always)]
149 pub fn value1(self) -> &'a mut crate::W<REG> {
150 self.variant(CCU42RS_A::VALUE1)
151 }
152 #[doc = "De-assert reset"]
153 #[inline(always)]
154 pub fn value2(self) -> &'a mut crate::W<REG> {
155 self.variant(CCU42RS_A::VALUE2)
156 }
157}
158#[doc = "CCU80 Reset Clear\n\nValue on reset: 0"]
159#[derive(Clone, Copy, Debug, PartialEq, Eq)]
160pub enum CCU80RS_A {
161 #[doc = "0: No effect"]
162 VALUE1 = 0,
163 #[doc = "1: De-assert reset"]
164 VALUE2 = 1,
165}
166impl From<CCU80RS_A> for bool {
167 #[inline(always)]
168 fn from(variant: CCU80RS_A) -> Self {
169 variant as u8 != 0
170 }
171}
172#[doc = "Field `CCU80RS` writer - CCU80 Reset Clear"]
173pub type CCU80RS_W<'a, REG> = crate::BitWriter<'a, REG, CCU80RS_A>;
174impl<'a, REG> CCU80RS_W<'a, REG>
175where
176 REG: crate::Writable + crate::RegisterSpec,
177{
178 #[doc = "No effect"]
179 #[inline(always)]
180 pub fn value1(self) -> &'a mut crate::W<REG> {
181 self.variant(CCU80RS_A::VALUE1)
182 }
183 #[doc = "De-assert reset"]
184 #[inline(always)]
185 pub fn value2(self) -> &'a mut crate::W<REG> {
186 self.variant(CCU80RS_A::VALUE2)
187 }
188}
189#[doc = "CCU81 Reset Clear\n\nValue on reset: 0"]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191pub enum CCU81RS_A {
192 #[doc = "0: No effect"]
193 VALUE1 = 0,
194 #[doc = "1: De-assert reset"]
195 VALUE2 = 1,
196}
197impl From<CCU81RS_A> for bool {
198 #[inline(always)]
199 fn from(variant: CCU81RS_A) -> Self {
200 variant as u8 != 0
201 }
202}
203#[doc = "Field `CCU81RS` writer - CCU81 Reset Clear"]
204pub type CCU81RS_W<'a, REG> = crate::BitWriter<'a, REG, CCU81RS_A>;
205impl<'a, REG> CCU81RS_W<'a, REG>
206where
207 REG: crate::Writable + crate::RegisterSpec,
208{
209 #[doc = "No effect"]
210 #[inline(always)]
211 pub fn value1(self) -> &'a mut crate::W<REG> {
212 self.variant(CCU81RS_A::VALUE1)
213 }
214 #[doc = "De-assert reset"]
215 #[inline(always)]
216 pub fn value2(self) -> &'a mut crate::W<REG> {
217 self.variant(CCU81RS_A::VALUE2)
218 }
219}
220#[doc = "POSIF0 Reset Clear\n\nValue on reset: 0"]
221#[derive(Clone, Copy, Debug, PartialEq, Eq)]
222pub enum POSIF0RS_A {
223 #[doc = "0: No effect"]
224 VALUE1 = 0,
225 #[doc = "1: De-assert reset"]
226 VALUE2 = 1,
227}
228impl From<POSIF0RS_A> for bool {
229 #[inline(always)]
230 fn from(variant: POSIF0RS_A) -> Self {
231 variant as u8 != 0
232 }
233}
234#[doc = "Field `POSIF0RS` writer - POSIF0 Reset Clear"]
235pub type POSIF0RS_W<'a, REG> = crate::BitWriter<'a, REG, POSIF0RS_A>;
236impl<'a, REG> POSIF0RS_W<'a, REG>
237where
238 REG: crate::Writable + crate::RegisterSpec,
239{
240 #[doc = "No effect"]
241 #[inline(always)]
242 pub fn value1(self) -> &'a mut crate::W<REG> {
243 self.variant(POSIF0RS_A::VALUE1)
244 }
245 #[doc = "De-assert reset"]
246 #[inline(always)]
247 pub fn value2(self) -> &'a mut crate::W<REG> {
248 self.variant(POSIF0RS_A::VALUE2)
249 }
250}
251#[doc = "POSIF1 Reset Clear\n\nValue on reset: 0"]
252#[derive(Clone, Copy, Debug, PartialEq, Eq)]
253pub enum POSIF1RS_A {
254 #[doc = "0: No effect"]
255 VALUE1 = 0,
256 #[doc = "1: De-assert reset"]
257 VALUE2 = 1,
258}
259impl From<POSIF1RS_A> for bool {
260 #[inline(always)]
261 fn from(variant: POSIF1RS_A) -> Self {
262 variant as u8 != 0
263 }
264}
265#[doc = "Field `POSIF1RS` writer - POSIF1 Reset Clear"]
266pub type POSIF1RS_W<'a, REG> = crate::BitWriter<'a, REG, POSIF1RS_A>;
267impl<'a, REG> POSIF1RS_W<'a, REG>
268where
269 REG: crate::Writable + crate::RegisterSpec,
270{
271 #[doc = "No effect"]
272 #[inline(always)]
273 pub fn value1(self) -> &'a mut crate::W<REG> {
274 self.variant(POSIF1RS_A::VALUE1)
275 }
276 #[doc = "De-assert reset"]
277 #[inline(always)]
278 pub fn value2(self) -> &'a mut crate::W<REG> {
279 self.variant(POSIF1RS_A::VALUE2)
280 }
281}
282#[doc = "USIC0 Reset Clear\n\nValue on reset: 0"]
283#[derive(Clone, Copy, Debug, PartialEq, Eq)]
284pub enum USIC0RS_A {
285 #[doc = "0: No effect"]
286 VALUE1 = 0,
287 #[doc = "1: De-assert reset"]
288 VALUE2 = 1,
289}
290impl From<USIC0RS_A> for bool {
291 #[inline(always)]
292 fn from(variant: USIC0RS_A) -> Self {
293 variant as u8 != 0
294 }
295}
296#[doc = "Field `USIC0RS` writer - USIC0 Reset Clear"]
297pub type USIC0RS_W<'a, REG> = crate::BitWriter<'a, REG, USIC0RS_A>;
298impl<'a, REG> USIC0RS_W<'a, REG>
299where
300 REG: crate::Writable + crate::RegisterSpec,
301{
302 #[doc = "No effect"]
303 #[inline(always)]
304 pub fn value1(self) -> &'a mut crate::W<REG> {
305 self.variant(USIC0RS_A::VALUE1)
306 }
307 #[doc = "De-assert reset"]
308 #[inline(always)]
309 pub fn value2(self) -> &'a mut crate::W<REG> {
310 self.variant(USIC0RS_A::VALUE2)
311 }
312}
313#[doc = "ERU1 Reset Clear\n\nValue on reset: 0"]
314#[derive(Clone, Copy, Debug, PartialEq, Eq)]
315pub enum ERU1RS_A {
316 #[doc = "0: No effect"]
317 VALUE1 = 0,
318 #[doc = "1: De-assert reset"]
319 VALUE2 = 1,
320}
321impl From<ERU1RS_A> for bool {
322 #[inline(always)]
323 fn from(variant: ERU1RS_A) -> Self {
324 variant as u8 != 0
325 }
326}
327#[doc = "Field `ERU1RS` writer - ERU1 Reset Clear"]
328pub type ERU1RS_W<'a, REG> = crate::BitWriter<'a, REG, ERU1RS_A>;
329impl<'a, REG> ERU1RS_W<'a, REG>
330where
331 REG: crate::Writable + crate::RegisterSpec,
332{
333 #[doc = "No effect"]
334 #[inline(always)]
335 pub fn value1(self) -> &'a mut crate::W<REG> {
336 self.variant(ERU1RS_A::VALUE1)
337 }
338 #[doc = "De-assert reset"]
339 #[inline(always)]
340 pub fn value2(self) -> &'a mut crate::W<REG> {
341 self.variant(ERU1RS_A::VALUE2)
342 }
343}
344impl W {
345 #[doc = "Bit 0 - VADC Reset Clear"]
346 #[inline(always)]
347 pub fn vadcrs(&mut self) -> VADCRS_W<PRCLR0_SPEC> {
348 VADCRS_W::new(self, 0)
349 }
350 #[doc = "Bit 1 - DSD Reset Clear"]
351 #[inline(always)]
352 pub fn dsdrs(&mut self) -> DSDRS_W<PRCLR0_SPEC> {
353 DSDRS_W::new(self, 1)
354 }
355 #[doc = "Bit 2 - CCU40 Reset Clear"]
356 #[inline(always)]
357 pub fn ccu40rs(&mut self) -> CCU40RS_W<PRCLR0_SPEC> {
358 CCU40RS_W::new(self, 2)
359 }
360 #[doc = "Bit 3 - CCU41 Reset Clear"]
361 #[inline(always)]
362 pub fn ccu41rs(&mut self) -> CCU41RS_W<PRCLR0_SPEC> {
363 CCU41RS_W::new(self, 3)
364 }
365 #[doc = "Bit 4 - CCU42 Reset Clear"]
366 #[inline(always)]
367 pub fn ccu42rs(&mut self) -> CCU42RS_W<PRCLR0_SPEC> {
368 CCU42RS_W::new(self, 4)
369 }
370 #[doc = "Bit 7 - CCU80 Reset Clear"]
371 #[inline(always)]
372 pub fn ccu80rs(&mut self) -> CCU80RS_W<PRCLR0_SPEC> {
373 CCU80RS_W::new(self, 7)
374 }
375 #[doc = "Bit 8 - CCU81 Reset Clear"]
376 #[inline(always)]
377 pub fn ccu81rs(&mut self) -> CCU81RS_W<PRCLR0_SPEC> {
378 CCU81RS_W::new(self, 8)
379 }
380 #[doc = "Bit 9 - POSIF0 Reset Clear"]
381 #[inline(always)]
382 pub fn posif0rs(&mut self) -> POSIF0RS_W<PRCLR0_SPEC> {
383 POSIF0RS_W::new(self, 9)
384 }
385 #[doc = "Bit 10 - POSIF1 Reset Clear"]
386 #[inline(always)]
387 pub fn posif1rs(&mut self) -> POSIF1RS_W<PRCLR0_SPEC> {
388 POSIF1RS_W::new(self, 10)
389 }
390 #[doc = "Bit 11 - USIC0 Reset Clear"]
391 #[inline(always)]
392 pub fn usic0rs(&mut self) -> USIC0RS_W<PRCLR0_SPEC> {
393 USIC0RS_W::new(self, 11)
394 }
395 #[doc = "Bit 16 - ERU1 Reset Clear"]
396 #[inline(always)]
397 pub fn eru1rs(&mut self) -> ERU1RS_W<PRCLR0_SPEC> {
398 ERU1RS_W::new(self, 16)
399 }
400}
401#[doc = "RCU Peripheral 0 Reset Clear\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`prclr0::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
402pub struct PRCLR0_SPEC;
403impl crate::RegisterSpec for PRCLR0_SPEC {
404 type Ux = u32;
405}
406#[doc = "`write(|w| ..)` method takes [`prclr0::W`](W) writer structure"]
407impl crate::Writable for PRCLR0_SPEC {
408 type Safety = crate::Unsafe;
409 const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
410 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
411}
412#[doc = "`reset()` method sets PRCLR0 to value 0"]
413impl crate::Resettable for PRCLR0_SPEC {
414 const RESET_VALUE: u32 = 0;
415}