1#[doc = "Reader of register ROUTELOC0"]
2pub type R = crate::R<u32, super::ROUTELOC0>;
3#[doc = "Writer for register ROUTELOC0"]
4pub type W = crate::W<u32, super::ROUTELOC0>;
5#[doc = "Register ROUTELOC0 `reset()`'s with value 0"]
6impl crate::ResetValue for super::ROUTELOC0 {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type { 0 }
10}
11#[doc = "I/O Location\n\nValue on reset: 0"]
12#[derive(Clone, Copy, Debug, PartialEq)]
13#[repr(u8)]
14pub enum CC0LOC_A {
15 #[doc = "0: Location 0"]
16 LOC0 = 0,
17 #[doc = "1: Location 1"]
18 LOC1 = 1,
19 #[doc = "2: Location 2"]
20 LOC2 = 2,
21 #[doc = "3: Location 3"]
22 LOC3 = 3,
23 #[doc = "4: Location 4"]
24 LOC4 = 4,
25 #[doc = "5: Location 5"]
26 LOC5 = 5,
27 #[doc = "6: Location 6"]
28 LOC6 = 6,
29 #[doc = "7: Location 7"]
30 LOC7 = 7,
31}
32impl From<CC0LOC_A> for u8 {
33 #[inline(always)]
34 fn from(variant: CC0LOC_A) -> Self { variant as _ }
35}
36#[doc = "Reader of field `CC0LOC`"]
37pub type CC0LOC_R = crate::R<u8, CC0LOC_A>;
38impl CC0LOC_R {
39 #[doc = r"Get enumerated values variant"]
40 #[inline(always)]
41 pub fn variant(&self) -> crate::Variant<u8, CC0LOC_A> {
42 use crate::Variant::*;
43 match self.bits {
44 0 => Val(CC0LOC_A::LOC0),
45 1 => Val(CC0LOC_A::LOC1),
46 2 => Val(CC0LOC_A::LOC2),
47 3 => Val(CC0LOC_A::LOC3),
48 4 => Val(CC0LOC_A::LOC4),
49 5 => Val(CC0LOC_A::LOC5),
50 6 => Val(CC0LOC_A::LOC6),
51 7 => Val(CC0LOC_A::LOC7),
52 i => Res(i),
53 }
54 }
55 #[doc = "Checks if the value of the field is `LOC0`"]
56 #[inline(always)]
57 pub fn is_loc0(&self) -> bool { *self == CC0LOC_A::LOC0 }
58 #[doc = "Checks if the value of the field is `LOC1`"]
59 #[inline(always)]
60 pub fn is_loc1(&self) -> bool { *self == CC0LOC_A::LOC1 }
61 #[doc = "Checks if the value of the field is `LOC2`"]
62 #[inline(always)]
63 pub fn is_loc2(&self) -> bool { *self == CC0LOC_A::LOC2 }
64 #[doc = "Checks if the value of the field is `LOC3`"]
65 #[inline(always)]
66 pub fn is_loc3(&self) -> bool { *self == CC0LOC_A::LOC3 }
67 #[doc = "Checks if the value of the field is `LOC4`"]
68 #[inline(always)]
69 pub fn is_loc4(&self) -> bool { *self == CC0LOC_A::LOC4 }
70 #[doc = "Checks if the value of the field is `LOC5`"]
71 #[inline(always)]
72 pub fn is_loc5(&self) -> bool { *self == CC0LOC_A::LOC5 }
73 #[doc = "Checks if the value of the field is `LOC6`"]
74 #[inline(always)]
75 pub fn is_loc6(&self) -> bool { *self == CC0LOC_A::LOC6 }
76 #[doc = "Checks if the value of the field is `LOC7`"]
77 #[inline(always)]
78 pub fn is_loc7(&self) -> bool { *self == CC0LOC_A::LOC7 }
79}
80#[doc = "Write proxy for field `CC0LOC`"]
81pub struct CC0LOC_W<'a> {
82 w: &'a mut W,
83}
84impl<'a> CC0LOC_W<'a> {
85 #[doc = r"Writes `variant` to the field"]
86 #[inline(always)]
87 pub fn variant(self, variant: CC0LOC_A) -> &'a mut W { unsafe { self.bits(variant.into()) } }
88 #[doc = "Location 0"]
89 #[inline(always)]
90 pub fn loc0(self) -> &'a mut W { self.variant(CC0LOC_A::LOC0) }
91 #[doc = "Location 1"]
92 #[inline(always)]
93 pub fn loc1(self) -> &'a mut W { self.variant(CC0LOC_A::LOC1) }
94 #[doc = "Location 2"]
95 #[inline(always)]
96 pub fn loc2(self) -> &'a mut W { self.variant(CC0LOC_A::LOC2) }
97 #[doc = "Location 3"]
98 #[inline(always)]
99 pub fn loc3(self) -> &'a mut W { self.variant(CC0LOC_A::LOC3) }
100 #[doc = "Location 4"]
101 #[inline(always)]
102 pub fn loc4(self) -> &'a mut W { self.variant(CC0LOC_A::LOC4) }
103 #[doc = "Location 5"]
104 #[inline(always)]
105 pub fn loc5(self) -> &'a mut W { self.variant(CC0LOC_A::LOC5) }
106 #[doc = "Location 6"]
107 #[inline(always)]
108 pub fn loc6(self) -> &'a mut W { self.variant(CC0LOC_A::LOC6) }
109 #[doc = "Location 7"]
110 #[inline(always)]
111 pub fn loc7(self) -> &'a mut W { self.variant(CC0LOC_A::LOC7) }
112 #[doc = r"Writes raw bits to the field"]
113 #[inline(always)]
114 pub unsafe fn bits(self, value: u8) -> &'a mut W {
115 self.w.bits = (self.w.bits & !0x3f) | ((value as u32) & 0x3f);
116 self.w
117 }
118}
119#[doc = "I/O Location\n\nValue on reset: 0"]
120#[derive(Clone, Copy, Debug, PartialEq)]
121#[repr(u8)]
122pub enum CC1LOC_A {
123 #[doc = "0: Location 0"]
124 LOC0 = 0,
125 #[doc = "1: Location 1"]
126 LOC1 = 1,
127 #[doc = "2: Location 2"]
128 LOC2 = 2,
129 #[doc = "3: Location 3"]
130 LOC3 = 3,
131 #[doc = "4: Location 4"]
132 LOC4 = 4,
133 #[doc = "5: Location 5"]
134 LOC5 = 5,
135 #[doc = "6: Location 6"]
136 LOC6 = 6,
137 #[doc = "7: Location 7"]
138 LOC7 = 7,
139}
140impl From<CC1LOC_A> for u8 {
141 #[inline(always)]
142 fn from(variant: CC1LOC_A) -> Self { variant as _ }
143}
144#[doc = "Reader of field `CC1LOC`"]
145pub type CC1LOC_R = crate::R<u8, CC1LOC_A>;
146impl CC1LOC_R {
147 #[doc = r"Get enumerated values variant"]
148 #[inline(always)]
149 pub fn variant(&self) -> crate::Variant<u8, CC1LOC_A> {
150 use crate::Variant::*;
151 match self.bits {
152 0 => Val(CC1LOC_A::LOC0),
153 1 => Val(CC1LOC_A::LOC1),
154 2 => Val(CC1LOC_A::LOC2),
155 3 => Val(CC1LOC_A::LOC3),
156 4 => Val(CC1LOC_A::LOC4),
157 5 => Val(CC1LOC_A::LOC5),
158 6 => Val(CC1LOC_A::LOC6),
159 7 => Val(CC1LOC_A::LOC7),
160 i => Res(i),
161 }
162 }
163 #[doc = "Checks if the value of the field is `LOC0`"]
164 #[inline(always)]
165 pub fn is_loc0(&self) -> bool { *self == CC1LOC_A::LOC0 }
166 #[doc = "Checks if the value of the field is `LOC1`"]
167 #[inline(always)]
168 pub fn is_loc1(&self) -> bool { *self == CC1LOC_A::LOC1 }
169 #[doc = "Checks if the value of the field is `LOC2`"]
170 #[inline(always)]
171 pub fn is_loc2(&self) -> bool { *self == CC1LOC_A::LOC2 }
172 #[doc = "Checks if the value of the field is `LOC3`"]
173 #[inline(always)]
174 pub fn is_loc3(&self) -> bool { *self == CC1LOC_A::LOC3 }
175 #[doc = "Checks if the value of the field is `LOC4`"]
176 #[inline(always)]
177 pub fn is_loc4(&self) -> bool { *self == CC1LOC_A::LOC4 }
178 #[doc = "Checks if the value of the field is `LOC5`"]
179 #[inline(always)]
180 pub fn is_loc5(&self) -> bool { *self == CC1LOC_A::LOC5 }
181 #[doc = "Checks if the value of the field is `LOC6`"]
182 #[inline(always)]
183 pub fn is_loc6(&self) -> bool { *self == CC1LOC_A::LOC6 }
184 #[doc = "Checks if the value of the field is `LOC7`"]
185 #[inline(always)]
186 pub fn is_loc7(&self) -> bool { *self == CC1LOC_A::LOC7 }
187}
188#[doc = "Write proxy for field `CC1LOC`"]
189pub struct CC1LOC_W<'a> {
190 w: &'a mut W,
191}
192impl<'a> CC1LOC_W<'a> {
193 #[doc = r"Writes `variant` to the field"]
194 #[inline(always)]
195 pub fn variant(self, variant: CC1LOC_A) -> &'a mut W { unsafe { self.bits(variant.into()) } }
196 #[doc = "Location 0"]
197 #[inline(always)]
198 pub fn loc0(self) -> &'a mut W { self.variant(CC1LOC_A::LOC0) }
199 #[doc = "Location 1"]
200 #[inline(always)]
201 pub fn loc1(self) -> &'a mut W { self.variant(CC1LOC_A::LOC1) }
202 #[doc = "Location 2"]
203 #[inline(always)]
204 pub fn loc2(self) -> &'a mut W { self.variant(CC1LOC_A::LOC2) }
205 #[doc = "Location 3"]
206 #[inline(always)]
207 pub fn loc3(self) -> &'a mut W { self.variant(CC1LOC_A::LOC3) }
208 #[doc = "Location 4"]
209 #[inline(always)]
210 pub fn loc4(self) -> &'a mut W { self.variant(CC1LOC_A::LOC4) }
211 #[doc = "Location 5"]
212 #[inline(always)]
213 pub fn loc5(self) -> &'a mut W { self.variant(CC1LOC_A::LOC5) }
214 #[doc = "Location 6"]
215 #[inline(always)]
216 pub fn loc6(self) -> &'a mut W { self.variant(CC1LOC_A::LOC6) }
217 #[doc = "Location 7"]
218 #[inline(always)]
219 pub fn loc7(self) -> &'a mut W { self.variant(CC1LOC_A::LOC7) }
220 #[doc = r"Writes raw bits to the field"]
221 #[inline(always)]
222 pub unsafe fn bits(self, value: u8) -> &'a mut W {
223 self.w.bits = (self.w.bits & !(0x3f << 8)) | (((value as u32) & 0x3f) << 8);
224 self.w
225 }
226}
227#[doc = "I/O Location\n\nValue on reset: 0"]
228#[derive(Clone, Copy, Debug, PartialEq)]
229#[repr(u8)]
230pub enum CC2LOC_A {
231 #[doc = "0: Location 0"]
232 LOC0 = 0,
233 #[doc = "1: Location 1"]
234 LOC1 = 1,
235 #[doc = "2: Location 2"]
236 LOC2 = 2,
237 #[doc = "3: Location 3"]
238 LOC3 = 3,
239 #[doc = "4: Location 4"]
240 LOC4 = 4,
241 #[doc = "5: Location 5"]
242 LOC5 = 5,
243 #[doc = "6: Location 6"]
244 LOC6 = 6,
245 #[doc = "7: Location 7"]
246 LOC7 = 7,
247}
248impl From<CC2LOC_A> for u8 {
249 #[inline(always)]
250 fn from(variant: CC2LOC_A) -> Self { variant as _ }
251}
252#[doc = "Reader of field `CC2LOC`"]
253pub type CC2LOC_R = crate::R<u8, CC2LOC_A>;
254impl CC2LOC_R {
255 #[doc = r"Get enumerated values variant"]
256 #[inline(always)]
257 pub fn variant(&self) -> crate::Variant<u8, CC2LOC_A> {
258 use crate::Variant::*;
259 match self.bits {
260 0 => Val(CC2LOC_A::LOC0),
261 1 => Val(CC2LOC_A::LOC1),
262 2 => Val(CC2LOC_A::LOC2),
263 3 => Val(CC2LOC_A::LOC3),
264 4 => Val(CC2LOC_A::LOC4),
265 5 => Val(CC2LOC_A::LOC5),
266 6 => Val(CC2LOC_A::LOC6),
267 7 => Val(CC2LOC_A::LOC7),
268 i => Res(i),
269 }
270 }
271 #[doc = "Checks if the value of the field is `LOC0`"]
272 #[inline(always)]
273 pub fn is_loc0(&self) -> bool { *self == CC2LOC_A::LOC0 }
274 #[doc = "Checks if the value of the field is `LOC1`"]
275 #[inline(always)]
276 pub fn is_loc1(&self) -> bool { *self == CC2LOC_A::LOC1 }
277 #[doc = "Checks if the value of the field is `LOC2`"]
278 #[inline(always)]
279 pub fn is_loc2(&self) -> bool { *self == CC2LOC_A::LOC2 }
280 #[doc = "Checks if the value of the field is `LOC3`"]
281 #[inline(always)]
282 pub fn is_loc3(&self) -> bool { *self == CC2LOC_A::LOC3 }
283 #[doc = "Checks if the value of the field is `LOC4`"]
284 #[inline(always)]
285 pub fn is_loc4(&self) -> bool { *self == CC2LOC_A::LOC4 }
286 #[doc = "Checks if the value of the field is `LOC5`"]
287 #[inline(always)]
288 pub fn is_loc5(&self) -> bool { *self == CC2LOC_A::LOC5 }
289 #[doc = "Checks if the value of the field is `LOC6`"]
290 #[inline(always)]
291 pub fn is_loc6(&self) -> bool { *self == CC2LOC_A::LOC6 }
292 #[doc = "Checks if the value of the field is `LOC7`"]
293 #[inline(always)]
294 pub fn is_loc7(&self) -> bool { *self == CC2LOC_A::LOC7 }
295}
296#[doc = "Write proxy for field `CC2LOC`"]
297pub struct CC2LOC_W<'a> {
298 w: &'a mut W,
299}
300impl<'a> CC2LOC_W<'a> {
301 #[doc = r"Writes `variant` to the field"]
302 #[inline(always)]
303 pub fn variant(self, variant: CC2LOC_A) -> &'a mut W { unsafe { self.bits(variant.into()) } }
304 #[doc = "Location 0"]
305 #[inline(always)]
306 pub fn loc0(self) -> &'a mut W { self.variant(CC2LOC_A::LOC0) }
307 #[doc = "Location 1"]
308 #[inline(always)]
309 pub fn loc1(self) -> &'a mut W { self.variant(CC2LOC_A::LOC1) }
310 #[doc = "Location 2"]
311 #[inline(always)]
312 pub fn loc2(self) -> &'a mut W { self.variant(CC2LOC_A::LOC2) }
313 #[doc = "Location 3"]
314 #[inline(always)]
315 pub fn loc3(self) -> &'a mut W { self.variant(CC2LOC_A::LOC3) }
316 #[doc = "Location 4"]
317 #[inline(always)]
318 pub fn loc4(self) -> &'a mut W { self.variant(CC2LOC_A::LOC4) }
319 #[doc = "Location 5"]
320 #[inline(always)]
321 pub fn loc5(self) -> &'a mut W { self.variant(CC2LOC_A::LOC5) }
322 #[doc = "Location 6"]
323 #[inline(always)]
324 pub fn loc6(self) -> &'a mut W { self.variant(CC2LOC_A::LOC6) }
325 #[doc = "Location 7"]
326 #[inline(always)]
327 pub fn loc7(self) -> &'a mut W { self.variant(CC2LOC_A::LOC7) }
328 #[doc = r"Writes raw bits to the field"]
329 #[inline(always)]
330 pub unsafe fn bits(self, value: u8) -> &'a mut W {
331 self.w.bits = (self.w.bits & !(0x3f << 16)) | (((value as u32) & 0x3f) << 16);
332 self.w
333 }
334}
335#[doc = "I/O Location\n\nValue on reset: 0"]
336#[derive(Clone, Copy, Debug, PartialEq)]
337#[repr(u8)]
338pub enum CC3LOC_A {
339 #[doc = "0: Location 0"]
340 LOC0 = 0,
341 #[doc = "1: Location 1"]
342 LOC1 = 1,
343 #[doc = "2: Location 2"]
344 LOC2 = 2,
345 #[doc = "3: Location 3"]
346 LOC3 = 3,
347 #[doc = "4: Location 4"]
348 LOC4 = 4,
349 #[doc = "5: Location 5"]
350 LOC5 = 5,
351 #[doc = "6: Location 6"]
352 LOC6 = 6,
353 #[doc = "7: Location 7"]
354 LOC7 = 7,
355}
356impl From<CC3LOC_A> for u8 {
357 #[inline(always)]
358 fn from(variant: CC3LOC_A) -> Self { variant as _ }
359}
360#[doc = "Reader of field `CC3LOC`"]
361pub type CC3LOC_R = crate::R<u8, CC3LOC_A>;
362impl CC3LOC_R {
363 #[doc = r"Get enumerated values variant"]
364 #[inline(always)]
365 pub fn variant(&self) -> crate::Variant<u8, CC3LOC_A> {
366 use crate::Variant::*;
367 match self.bits {
368 0 => Val(CC3LOC_A::LOC0),
369 1 => Val(CC3LOC_A::LOC1),
370 2 => Val(CC3LOC_A::LOC2),
371 3 => Val(CC3LOC_A::LOC3),
372 4 => Val(CC3LOC_A::LOC4),
373 5 => Val(CC3LOC_A::LOC5),
374 6 => Val(CC3LOC_A::LOC6),
375 7 => Val(CC3LOC_A::LOC7),
376 i => Res(i),
377 }
378 }
379 #[doc = "Checks if the value of the field is `LOC0`"]
380 #[inline(always)]
381 pub fn is_loc0(&self) -> bool { *self == CC3LOC_A::LOC0 }
382 #[doc = "Checks if the value of the field is `LOC1`"]
383 #[inline(always)]
384 pub fn is_loc1(&self) -> bool { *self == CC3LOC_A::LOC1 }
385 #[doc = "Checks if the value of the field is `LOC2`"]
386 #[inline(always)]
387 pub fn is_loc2(&self) -> bool { *self == CC3LOC_A::LOC2 }
388 #[doc = "Checks if the value of the field is `LOC3`"]
389 #[inline(always)]
390 pub fn is_loc3(&self) -> bool { *self == CC3LOC_A::LOC3 }
391 #[doc = "Checks if the value of the field is `LOC4`"]
392 #[inline(always)]
393 pub fn is_loc4(&self) -> bool { *self == CC3LOC_A::LOC4 }
394 #[doc = "Checks if the value of the field is `LOC5`"]
395 #[inline(always)]
396 pub fn is_loc5(&self) -> bool { *self == CC3LOC_A::LOC5 }
397 #[doc = "Checks if the value of the field is `LOC6`"]
398 #[inline(always)]
399 pub fn is_loc6(&self) -> bool { *self == CC3LOC_A::LOC6 }
400 #[doc = "Checks if the value of the field is `LOC7`"]
401 #[inline(always)]
402 pub fn is_loc7(&self) -> bool { *self == CC3LOC_A::LOC7 }
403}
404#[doc = "Write proxy for field `CC3LOC`"]
405pub struct CC3LOC_W<'a> {
406 w: &'a mut W,
407}
408impl<'a> CC3LOC_W<'a> {
409 #[doc = r"Writes `variant` to the field"]
410 #[inline(always)]
411 pub fn variant(self, variant: CC3LOC_A) -> &'a mut W { unsafe { self.bits(variant.into()) } }
412 #[doc = "Location 0"]
413 #[inline(always)]
414 pub fn loc0(self) -> &'a mut W { self.variant(CC3LOC_A::LOC0) }
415 #[doc = "Location 1"]
416 #[inline(always)]
417 pub fn loc1(self) -> &'a mut W { self.variant(CC3LOC_A::LOC1) }
418 #[doc = "Location 2"]
419 #[inline(always)]
420 pub fn loc2(self) -> &'a mut W { self.variant(CC3LOC_A::LOC2) }
421 #[doc = "Location 3"]
422 #[inline(always)]
423 pub fn loc3(self) -> &'a mut W { self.variant(CC3LOC_A::LOC3) }
424 #[doc = "Location 4"]
425 #[inline(always)]
426 pub fn loc4(self) -> &'a mut W { self.variant(CC3LOC_A::LOC4) }
427 #[doc = "Location 5"]
428 #[inline(always)]
429 pub fn loc5(self) -> &'a mut W { self.variant(CC3LOC_A::LOC5) }
430 #[doc = "Location 6"]
431 #[inline(always)]
432 pub fn loc6(self) -> &'a mut W { self.variant(CC3LOC_A::LOC6) }
433 #[doc = "Location 7"]
434 #[inline(always)]
435 pub fn loc7(self) -> &'a mut W { self.variant(CC3LOC_A::LOC7) }
436 #[doc = r"Writes raw bits to the field"]
437 #[inline(always)]
438 pub unsafe fn bits(self, value: u8) -> &'a mut W {
439 self.w.bits = (self.w.bits & !(0x3f << 24)) | (((value as u32) & 0x3f) << 24);
440 self.w
441 }
442}
443impl R {
444 #[doc = "Bits 0:5 - I/O Location"]
445 #[inline(always)]
446 pub fn cc0loc(&self) -> CC0LOC_R { CC0LOC_R::new((self.bits & 0x3f) as u8) }
447 #[doc = "Bits 8:13 - I/O Location"]
448 #[inline(always)]
449 pub fn cc1loc(&self) -> CC1LOC_R { CC1LOC_R::new(((self.bits >> 8) & 0x3f) as u8) }
450 #[doc = "Bits 16:21 - I/O Location"]
451 #[inline(always)]
452 pub fn cc2loc(&self) -> CC2LOC_R { CC2LOC_R::new(((self.bits >> 16) & 0x3f) as u8) }
453 #[doc = "Bits 24:29 - I/O Location"]
454 #[inline(always)]
455 pub fn cc3loc(&self) -> CC3LOC_R { CC3LOC_R::new(((self.bits >> 24) & 0x3f) as u8) }
456}
457impl W {
458 #[doc = "Bits 0:5 - I/O Location"]
459 #[inline(always)]
460 pub fn cc0loc(&mut self) -> CC0LOC_W { CC0LOC_W { w: self } }
461 #[doc = "Bits 8:13 - I/O Location"]
462 #[inline(always)]
463 pub fn cc1loc(&mut self) -> CC1LOC_W { CC1LOC_W { w: self } }
464 #[doc = "Bits 16:21 - I/O Location"]
465 #[inline(always)]
466 pub fn cc2loc(&mut self) -> CC2LOC_W { CC2LOC_W { w: self } }
467 #[doc = "Bits 24:29 - I/O Location"]
468 #[inline(always)]
469 pub fn cc3loc(&mut self) -> CC3LOC_W { CC3LOC_W { w: self } }
470}