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 {
10 0
11 }
12}
13#[doc = "I/O Location\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15#[repr(u8)]
16pub enum CH0LOC_A {
17 #[doc = "0: Location 0"]
18 LOC0 = 0,
19 #[doc = "1: Location 1"]
20 LOC1 = 1,
21 #[doc = "2: Location 2"]
22 LOC2 = 2,
23 #[doc = "3: Location 3"]
24 LOC3 = 3,
25 #[doc = "4: Location 4"]
26 LOC4 = 4,
27 #[doc = "5: Location 5"]
28 LOC5 = 5,
29 #[doc = "6: Location 6"]
30 LOC6 = 6,
31 #[doc = "7: Location 7"]
32 LOC7 = 7,
33 #[doc = "8: Location 8"]
34 LOC8 = 8,
35 #[doc = "9: Location 9"]
36 LOC9 = 9,
37 #[doc = "10: Location 10"]
38 LOC10 = 10,
39 #[doc = "11: Location 11"]
40 LOC11 = 11,
41 #[doc = "12: Location 12"]
42 LOC12 = 12,
43 #[doc = "13: Location 13"]
44 LOC13 = 13,
45}
46impl From<CH0LOC_A> for u8 {
47 #[inline(always)]
48 fn from(variant: CH0LOC_A) -> Self {
49 variant as _
50 }
51}
52#[doc = "Reader of field `CH0LOC`"]
53pub type CH0LOC_R = crate::R<u8, CH0LOC_A>;
54impl CH0LOC_R {
55 #[doc = r"Get enumerated values variant"]
56 #[inline(always)]
57 pub fn variant(&self) -> crate::Variant<u8, CH0LOC_A> {
58 use crate::Variant::*;
59 match self.bits {
60 0 => Val(CH0LOC_A::LOC0),
61 1 => Val(CH0LOC_A::LOC1),
62 2 => Val(CH0LOC_A::LOC2),
63 3 => Val(CH0LOC_A::LOC3),
64 4 => Val(CH0LOC_A::LOC4),
65 5 => Val(CH0LOC_A::LOC5),
66 6 => Val(CH0LOC_A::LOC6),
67 7 => Val(CH0LOC_A::LOC7),
68 8 => Val(CH0LOC_A::LOC8),
69 9 => Val(CH0LOC_A::LOC9),
70 10 => Val(CH0LOC_A::LOC10),
71 11 => Val(CH0LOC_A::LOC11),
72 12 => Val(CH0LOC_A::LOC12),
73 13 => Val(CH0LOC_A::LOC13),
74 i => Res(i),
75 }
76 }
77 #[doc = "Checks if the value of the field is `LOC0`"]
78 #[inline(always)]
79 pub fn is_loc0(&self) -> bool {
80 *self == CH0LOC_A::LOC0
81 }
82 #[doc = "Checks if the value of the field is `LOC1`"]
83 #[inline(always)]
84 pub fn is_loc1(&self) -> bool {
85 *self == CH0LOC_A::LOC1
86 }
87 #[doc = "Checks if the value of the field is `LOC2`"]
88 #[inline(always)]
89 pub fn is_loc2(&self) -> bool {
90 *self == CH0LOC_A::LOC2
91 }
92 #[doc = "Checks if the value of the field is `LOC3`"]
93 #[inline(always)]
94 pub fn is_loc3(&self) -> bool {
95 *self == CH0LOC_A::LOC3
96 }
97 #[doc = "Checks if the value of the field is `LOC4`"]
98 #[inline(always)]
99 pub fn is_loc4(&self) -> bool {
100 *self == CH0LOC_A::LOC4
101 }
102 #[doc = "Checks if the value of the field is `LOC5`"]
103 #[inline(always)]
104 pub fn is_loc5(&self) -> bool {
105 *self == CH0LOC_A::LOC5
106 }
107 #[doc = "Checks if the value of the field is `LOC6`"]
108 #[inline(always)]
109 pub fn is_loc6(&self) -> bool {
110 *self == CH0LOC_A::LOC6
111 }
112 #[doc = "Checks if the value of the field is `LOC7`"]
113 #[inline(always)]
114 pub fn is_loc7(&self) -> bool {
115 *self == CH0LOC_A::LOC7
116 }
117 #[doc = "Checks if the value of the field is `LOC8`"]
118 #[inline(always)]
119 pub fn is_loc8(&self) -> bool {
120 *self == CH0LOC_A::LOC8
121 }
122 #[doc = "Checks if the value of the field is `LOC9`"]
123 #[inline(always)]
124 pub fn is_loc9(&self) -> bool {
125 *self == CH0LOC_A::LOC9
126 }
127 #[doc = "Checks if the value of the field is `LOC10`"]
128 #[inline(always)]
129 pub fn is_loc10(&self) -> bool {
130 *self == CH0LOC_A::LOC10
131 }
132 #[doc = "Checks if the value of the field is `LOC11`"]
133 #[inline(always)]
134 pub fn is_loc11(&self) -> bool {
135 *self == CH0LOC_A::LOC11
136 }
137 #[doc = "Checks if the value of the field is `LOC12`"]
138 #[inline(always)]
139 pub fn is_loc12(&self) -> bool {
140 *self == CH0LOC_A::LOC12
141 }
142 #[doc = "Checks if the value of the field is `LOC13`"]
143 #[inline(always)]
144 pub fn is_loc13(&self) -> bool {
145 *self == CH0LOC_A::LOC13
146 }
147}
148#[doc = "Write proxy for field `CH0LOC`"]
149pub struct CH0LOC_W<'a> {
150 w: &'a mut W,
151}
152impl<'a> CH0LOC_W<'a> {
153 #[doc = r"Writes `variant` to the field"]
154 #[inline(always)]
155 pub fn variant(self, variant: CH0LOC_A) -> &'a mut W {
156 unsafe { self.bits(variant.into()) }
157 }
158 #[doc = "Location 0"]
159 #[inline(always)]
160 pub fn loc0(self) -> &'a mut W {
161 self.variant(CH0LOC_A::LOC0)
162 }
163 #[doc = "Location 1"]
164 #[inline(always)]
165 pub fn loc1(self) -> &'a mut W {
166 self.variant(CH0LOC_A::LOC1)
167 }
168 #[doc = "Location 2"]
169 #[inline(always)]
170 pub fn loc2(self) -> &'a mut W {
171 self.variant(CH0LOC_A::LOC2)
172 }
173 #[doc = "Location 3"]
174 #[inline(always)]
175 pub fn loc3(self) -> &'a mut W {
176 self.variant(CH0LOC_A::LOC3)
177 }
178 #[doc = "Location 4"]
179 #[inline(always)]
180 pub fn loc4(self) -> &'a mut W {
181 self.variant(CH0LOC_A::LOC4)
182 }
183 #[doc = "Location 5"]
184 #[inline(always)]
185 pub fn loc5(self) -> &'a mut W {
186 self.variant(CH0LOC_A::LOC5)
187 }
188 #[doc = "Location 6"]
189 #[inline(always)]
190 pub fn loc6(self) -> &'a mut W {
191 self.variant(CH0LOC_A::LOC6)
192 }
193 #[doc = "Location 7"]
194 #[inline(always)]
195 pub fn loc7(self) -> &'a mut W {
196 self.variant(CH0LOC_A::LOC7)
197 }
198 #[doc = "Location 8"]
199 #[inline(always)]
200 pub fn loc8(self) -> &'a mut W {
201 self.variant(CH0LOC_A::LOC8)
202 }
203 #[doc = "Location 9"]
204 #[inline(always)]
205 pub fn loc9(self) -> &'a mut W {
206 self.variant(CH0LOC_A::LOC9)
207 }
208 #[doc = "Location 10"]
209 #[inline(always)]
210 pub fn loc10(self) -> &'a mut W {
211 self.variant(CH0LOC_A::LOC10)
212 }
213 #[doc = "Location 11"]
214 #[inline(always)]
215 pub fn loc11(self) -> &'a mut W {
216 self.variant(CH0LOC_A::LOC11)
217 }
218 #[doc = "Location 12"]
219 #[inline(always)]
220 pub fn loc12(self) -> &'a mut W {
221 self.variant(CH0LOC_A::LOC12)
222 }
223 #[doc = "Location 13"]
224 #[inline(always)]
225 pub fn loc13(self) -> &'a mut W {
226 self.variant(CH0LOC_A::LOC13)
227 }
228 #[doc = r"Writes raw bits to the field"]
229 #[inline(always)]
230 pub unsafe fn bits(self, value: u8) -> &'a mut W {
231 self.w.bits = (self.w.bits & !0x3f) | ((value as u32) & 0x3f);
232 self.w
233 }
234}
235#[doc = "I/O Location\n\nValue on reset: 0"]
236#[derive(Clone, Copy, Debug, PartialEq)]
237#[repr(u8)]
238pub enum CH1LOC_A {
239 #[doc = "0: Location 0"]
240 LOC0 = 0,
241 #[doc = "1: Location 1"]
242 LOC1 = 1,
243 #[doc = "2: Location 2"]
244 LOC2 = 2,
245 #[doc = "3: Location 3"]
246 LOC3 = 3,
247 #[doc = "4: Location 4"]
248 LOC4 = 4,
249 #[doc = "5: Location 5"]
250 LOC5 = 5,
251 #[doc = "6: Location 6"]
252 LOC6 = 6,
253 #[doc = "7: Location 7"]
254 LOC7 = 7,
255}
256impl From<CH1LOC_A> for u8 {
257 #[inline(always)]
258 fn from(variant: CH1LOC_A) -> Self {
259 variant as _
260 }
261}
262#[doc = "Reader of field `CH1LOC`"]
263pub type CH1LOC_R = crate::R<u8, CH1LOC_A>;
264impl CH1LOC_R {
265 #[doc = r"Get enumerated values variant"]
266 #[inline(always)]
267 pub fn variant(&self) -> crate::Variant<u8, CH1LOC_A> {
268 use crate::Variant::*;
269 match self.bits {
270 0 => Val(CH1LOC_A::LOC0),
271 1 => Val(CH1LOC_A::LOC1),
272 2 => Val(CH1LOC_A::LOC2),
273 3 => Val(CH1LOC_A::LOC3),
274 4 => Val(CH1LOC_A::LOC4),
275 5 => Val(CH1LOC_A::LOC5),
276 6 => Val(CH1LOC_A::LOC6),
277 7 => Val(CH1LOC_A::LOC7),
278 i => Res(i),
279 }
280 }
281 #[doc = "Checks if the value of the field is `LOC0`"]
282 #[inline(always)]
283 pub fn is_loc0(&self) -> bool {
284 *self == CH1LOC_A::LOC0
285 }
286 #[doc = "Checks if the value of the field is `LOC1`"]
287 #[inline(always)]
288 pub fn is_loc1(&self) -> bool {
289 *self == CH1LOC_A::LOC1
290 }
291 #[doc = "Checks if the value of the field is `LOC2`"]
292 #[inline(always)]
293 pub fn is_loc2(&self) -> bool {
294 *self == CH1LOC_A::LOC2
295 }
296 #[doc = "Checks if the value of the field is `LOC3`"]
297 #[inline(always)]
298 pub fn is_loc3(&self) -> bool {
299 *self == CH1LOC_A::LOC3
300 }
301 #[doc = "Checks if the value of the field is `LOC4`"]
302 #[inline(always)]
303 pub fn is_loc4(&self) -> bool {
304 *self == CH1LOC_A::LOC4
305 }
306 #[doc = "Checks if the value of the field is `LOC5`"]
307 #[inline(always)]
308 pub fn is_loc5(&self) -> bool {
309 *self == CH1LOC_A::LOC5
310 }
311 #[doc = "Checks if the value of the field is `LOC6`"]
312 #[inline(always)]
313 pub fn is_loc6(&self) -> bool {
314 *self == CH1LOC_A::LOC6
315 }
316 #[doc = "Checks if the value of the field is `LOC7`"]
317 #[inline(always)]
318 pub fn is_loc7(&self) -> bool {
319 *self == CH1LOC_A::LOC7
320 }
321}
322#[doc = "Write proxy for field `CH1LOC`"]
323pub struct CH1LOC_W<'a> {
324 w: &'a mut W,
325}
326impl<'a> CH1LOC_W<'a> {
327 #[doc = r"Writes `variant` to the field"]
328 #[inline(always)]
329 pub fn variant(self, variant: CH1LOC_A) -> &'a mut W {
330 unsafe { self.bits(variant.into()) }
331 }
332 #[doc = "Location 0"]
333 #[inline(always)]
334 pub fn loc0(self) -> &'a mut W {
335 self.variant(CH1LOC_A::LOC0)
336 }
337 #[doc = "Location 1"]
338 #[inline(always)]
339 pub fn loc1(self) -> &'a mut W {
340 self.variant(CH1LOC_A::LOC1)
341 }
342 #[doc = "Location 2"]
343 #[inline(always)]
344 pub fn loc2(self) -> &'a mut W {
345 self.variant(CH1LOC_A::LOC2)
346 }
347 #[doc = "Location 3"]
348 #[inline(always)]
349 pub fn loc3(self) -> &'a mut W {
350 self.variant(CH1LOC_A::LOC3)
351 }
352 #[doc = "Location 4"]
353 #[inline(always)]
354 pub fn loc4(self) -> &'a mut W {
355 self.variant(CH1LOC_A::LOC4)
356 }
357 #[doc = "Location 5"]
358 #[inline(always)]
359 pub fn loc5(self) -> &'a mut W {
360 self.variant(CH1LOC_A::LOC5)
361 }
362 #[doc = "Location 6"]
363 #[inline(always)]
364 pub fn loc6(self) -> &'a mut W {
365 self.variant(CH1LOC_A::LOC6)
366 }
367 #[doc = "Location 7"]
368 #[inline(always)]
369 pub fn loc7(self) -> &'a mut W {
370 self.variant(CH1LOC_A::LOC7)
371 }
372 #[doc = r"Writes raw bits to the field"]
373 #[inline(always)]
374 pub unsafe fn bits(self, value: u8) -> &'a mut W {
375 self.w.bits = (self.w.bits & !(0x3f << 8)) | (((value as u32) & 0x3f) << 8);
376 self.w
377 }
378}
379#[doc = "I/O Location\n\nValue on reset: 0"]
380#[derive(Clone, Copy, Debug, PartialEq)]
381#[repr(u8)]
382pub enum CH2LOC_A {
383 #[doc = "0: Location 0"]
384 LOC0 = 0,
385 #[doc = "1: Location 1"]
386 LOC1 = 1,
387 #[doc = "2: Location 2"]
388 LOC2 = 2,
389 #[doc = "3: Location 3"]
390 LOC3 = 3,
391 #[doc = "4: Location 4"]
392 LOC4 = 4,
393 #[doc = "5: Location 5"]
394 LOC5 = 5,
395 #[doc = "6: Location 6"]
396 LOC6 = 6,
397 #[doc = "7: Location 7"]
398 LOC7 = 7,
399}
400impl From<CH2LOC_A> for u8 {
401 #[inline(always)]
402 fn from(variant: CH2LOC_A) -> Self {
403 variant as _
404 }
405}
406#[doc = "Reader of field `CH2LOC`"]
407pub type CH2LOC_R = crate::R<u8, CH2LOC_A>;
408impl CH2LOC_R {
409 #[doc = r"Get enumerated values variant"]
410 #[inline(always)]
411 pub fn variant(&self) -> crate::Variant<u8, CH2LOC_A> {
412 use crate::Variant::*;
413 match self.bits {
414 0 => Val(CH2LOC_A::LOC0),
415 1 => Val(CH2LOC_A::LOC1),
416 2 => Val(CH2LOC_A::LOC2),
417 3 => Val(CH2LOC_A::LOC3),
418 4 => Val(CH2LOC_A::LOC4),
419 5 => Val(CH2LOC_A::LOC5),
420 6 => Val(CH2LOC_A::LOC6),
421 7 => Val(CH2LOC_A::LOC7),
422 i => Res(i),
423 }
424 }
425 #[doc = "Checks if the value of the field is `LOC0`"]
426 #[inline(always)]
427 pub fn is_loc0(&self) -> bool {
428 *self == CH2LOC_A::LOC0
429 }
430 #[doc = "Checks if the value of the field is `LOC1`"]
431 #[inline(always)]
432 pub fn is_loc1(&self) -> bool {
433 *self == CH2LOC_A::LOC1
434 }
435 #[doc = "Checks if the value of the field is `LOC2`"]
436 #[inline(always)]
437 pub fn is_loc2(&self) -> bool {
438 *self == CH2LOC_A::LOC2
439 }
440 #[doc = "Checks if the value of the field is `LOC3`"]
441 #[inline(always)]
442 pub fn is_loc3(&self) -> bool {
443 *self == CH2LOC_A::LOC3
444 }
445 #[doc = "Checks if the value of the field is `LOC4`"]
446 #[inline(always)]
447 pub fn is_loc4(&self) -> bool {
448 *self == CH2LOC_A::LOC4
449 }
450 #[doc = "Checks if the value of the field is `LOC5`"]
451 #[inline(always)]
452 pub fn is_loc5(&self) -> bool {
453 *self == CH2LOC_A::LOC5
454 }
455 #[doc = "Checks if the value of the field is `LOC6`"]
456 #[inline(always)]
457 pub fn is_loc6(&self) -> bool {
458 *self == CH2LOC_A::LOC6
459 }
460 #[doc = "Checks if the value of the field is `LOC7`"]
461 #[inline(always)]
462 pub fn is_loc7(&self) -> bool {
463 *self == CH2LOC_A::LOC7
464 }
465}
466#[doc = "Write proxy for field `CH2LOC`"]
467pub struct CH2LOC_W<'a> {
468 w: &'a mut W,
469}
470impl<'a> CH2LOC_W<'a> {
471 #[doc = r"Writes `variant` to the field"]
472 #[inline(always)]
473 pub fn variant(self, variant: CH2LOC_A) -> &'a mut W {
474 unsafe { self.bits(variant.into()) }
475 }
476 #[doc = "Location 0"]
477 #[inline(always)]
478 pub fn loc0(self) -> &'a mut W {
479 self.variant(CH2LOC_A::LOC0)
480 }
481 #[doc = "Location 1"]
482 #[inline(always)]
483 pub fn loc1(self) -> &'a mut W {
484 self.variant(CH2LOC_A::LOC1)
485 }
486 #[doc = "Location 2"]
487 #[inline(always)]
488 pub fn loc2(self) -> &'a mut W {
489 self.variant(CH2LOC_A::LOC2)
490 }
491 #[doc = "Location 3"]
492 #[inline(always)]
493 pub fn loc3(self) -> &'a mut W {
494 self.variant(CH2LOC_A::LOC3)
495 }
496 #[doc = "Location 4"]
497 #[inline(always)]
498 pub fn loc4(self) -> &'a mut W {
499 self.variant(CH2LOC_A::LOC4)
500 }
501 #[doc = "Location 5"]
502 #[inline(always)]
503 pub fn loc5(self) -> &'a mut W {
504 self.variant(CH2LOC_A::LOC5)
505 }
506 #[doc = "Location 6"]
507 #[inline(always)]
508 pub fn loc6(self) -> &'a mut W {
509 self.variant(CH2LOC_A::LOC6)
510 }
511 #[doc = "Location 7"]
512 #[inline(always)]
513 pub fn loc7(self) -> &'a mut W {
514 self.variant(CH2LOC_A::LOC7)
515 }
516 #[doc = r"Writes raw bits to the field"]
517 #[inline(always)]
518 pub unsafe fn bits(self, value: u8) -> &'a mut W {
519 self.w.bits = (self.w.bits & !(0x3f << 16)) | (((value as u32) & 0x3f) << 16);
520 self.w
521 }
522}
523#[doc = "I/O Location\n\nValue on reset: 0"]
524#[derive(Clone, Copy, Debug, PartialEq)]
525#[repr(u8)]
526pub enum CH3LOC_A {
527 #[doc = "0: Location 0"]
528 LOC0 = 0,
529 #[doc = "1: Location 1"]
530 LOC1 = 1,
531 #[doc = "2: Location 2"]
532 LOC2 = 2,
533 #[doc = "3: Location 3"]
534 LOC3 = 3,
535 #[doc = "4: Location 4"]
536 LOC4 = 4,
537 #[doc = "5: Location 5"]
538 LOC5 = 5,
539 #[doc = "6: Location 6"]
540 LOC6 = 6,
541 #[doc = "7: Location 7"]
542 LOC7 = 7,
543 #[doc = "8: Location 8"]
544 LOC8 = 8,
545 #[doc = "9: Location 9"]
546 LOC9 = 9,
547 #[doc = "10: Location 10"]
548 LOC10 = 10,
549 #[doc = "11: Location 11"]
550 LOC11 = 11,
551 #[doc = "12: Location 12"]
552 LOC12 = 12,
553 #[doc = "13: Location 13"]
554 LOC13 = 13,
555 #[doc = "14: Location 14"]
556 LOC14 = 14,
557}
558impl From<CH3LOC_A> for u8 {
559 #[inline(always)]
560 fn from(variant: CH3LOC_A) -> Self {
561 variant as _
562 }
563}
564#[doc = "Reader of field `CH3LOC`"]
565pub type CH3LOC_R = crate::R<u8, CH3LOC_A>;
566impl CH3LOC_R {
567 #[doc = r"Get enumerated values variant"]
568 #[inline(always)]
569 pub fn variant(&self) -> crate::Variant<u8, CH3LOC_A> {
570 use crate::Variant::*;
571 match self.bits {
572 0 => Val(CH3LOC_A::LOC0),
573 1 => Val(CH3LOC_A::LOC1),
574 2 => Val(CH3LOC_A::LOC2),
575 3 => Val(CH3LOC_A::LOC3),
576 4 => Val(CH3LOC_A::LOC4),
577 5 => Val(CH3LOC_A::LOC5),
578 6 => Val(CH3LOC_A::LOC6),
579 7 => Val(CH3LOC_A::LOC7),
580 8 => Val(CH3LOC_A::LOC8),
581 9 => Val(CH3LOC_A::LOC9),
582 10 => Val(CH3LOC_A::LOC10),
583 11 => Val(CH3LOC_A::LOC11),
584 12 => Val(CH3LOC_A::LOC12),
585 13 => Val(CH3LOC_A::LOC13),
586 14 => Val(CH3LOC_A::LOC14),
587 i => Res(i),
588 }
589 }
590 #[doc = "Checks if the value of the field is `LOC0`"]
591 #[inline(always)]
592 pub fn is_loc0(&self) -> bool {
593 *self == CH3LOC_A::LOC0
594 }
595 #[doc = "Checks if the value of the field is `LOC1`"]
596 #[inline(always)]
597 pub fn is_loc1(&self) -> bool {
598 *self == CH3LOC_A::LOC1
599 }
600 #[doc = "Checks if the value of the field is `LOC2`"]
601 #[inline(always)]
602 pub fn is_loc2(&self) -> bool {
603 *self == CH3LOC_A::LOC2
604 }
605 #[doc = "Checks if the value of the field is `LOC3`"]
606 #[inline(always)]
607 pub fn is_loc3(&self) -> bool {
608 *self == CH3LOC_A::LOC3
609 }
610 #[doc = "Checks if the value of the field is `LOC4`"]
611 #[inline(always)]
612 pub fn is_loc4(&self) -> bool {
613 *self == CH3LOC_A::LOC4
614 }
615 #[doc = "Checks if the value of the field is `LOC5`"]
616 #[inline(always)]
617 pub fn is_loc5(&self) -> bool {
618 *self == CH3LOC_A::LOC5
619 }
620 #[doc = "Checks if the value of the field is `LOC6`"]
621 #[inline(always)]
622 pub fn is_loc6(&self) -> bool {
623 *self == CH3LOC_A::LOC6
624 }
625 #[doc = "Checks if the value of the field is `LOC7`"]
626 #[inline(always)]
627 pub fn is_loc7(&self) -> bool {
628 *self == CH3LOC_A::LOC7
629 }
630 #[doc = "Checks if the value of the field is `LOC8`"]
631 #[inline(always)]
632 pub fn is_loc8(&self) -> bool {
633 *self == CH3LOC_A::LOC8
634 }
635 #[doc = "Checks if the value of the field is `LOC9`"]
636 #[inline(always)]
637 pub fn is_loc9(&self) -> bool {
638 *self == CH3LOC_A::LOC9
639 }
640 #[doc = "Checks if the value of the field is `LOC10`"]
641 #[inline(always)]
642 pub fn is_loc10(&self) -> bool {
643 *self == CH3LOC_A::LOC10
644 }
645 #[doc = "Checks if the value of the field is `LOC11`"]
646 #[inline(always)]
647 pub fn is_loc11(&self) -> bool {
648 *self == CH3LOC_A::LOC11
649 }
650 #[doc = "Checks if the value of the field is `LOC12`"]
651 #[inline(always)]
652 pub fn is_loc12(&self) -> bool {
653 *self == CH3LOC_A::LOC12
654 }
655 #[doc = "Checks if the value of the field is `LOC13`"]
656 #[inline(always)]
657 pub fn is_loc13(&self) -> bool {
658 *self == CH3LOC_A::LOC13
659 }
660 #[doc = "Checks if the value of the field is `LOC14`"]
661 #[inline(always)]
662 pub fn is_loc14(&self) -> bool {
663 *self == CH3LOC_A::LOC14
664 }
665}
666#[doc = "Write proxy for field `CH3LOC`"]
667pub struct CH3LOC_W<'a> {
668 w: &'a mut W,
669}
670impl<'a> CH3LOC_W<'a> {
671 #[doc = r"Writes `variant` to the field"]
672 #[inline(always)]
673 pub fn variant(self, variant: CH3LOC_A) -> &'a mut W {
674 unsafe { self.bits(variant.into()) }
675 }
676 #[doc = "Location 0"]
677 #[inline(always)]
678 pub fn loc0(self) -> &'a mut W {
679 self.variant(CH3LOC_A::LOC0)
680 }
681 #[doc = "Location 1"]
682 #[inline(always)]
683 pub fn loc1(self) -> &'a mut W {
684 self.variant(CH3LOC_A::LOC1)
685 }
686 #[doc = "Location 2"]
687 #[inline(always)]
688 pub fn loc2(self) -> &'a mut W {
689 self.variant(CH3LOC_A::LOC2)
690 }
691 #[doc = "Location 3"]
692 #[inline(always)]
693 pub fn loc3(self) -> &'a mut W {
694 self.variant(CH3LOC_A::LOC3)
695 }
696 #[doc = "Location 4"]
697 #[inline(always)]
698 pub fn loc4(self) -> &'a mut W {
699 self.variant(CH3LOC_A::LOC4)
700 }
701 #[doc = "Location 5"]
702 #[inline(always)]
703 pub fn loc5(self) -> &'a mut W {
704 self.variant(CH3LOC_A::LOC5)
705 }
706 #[doc = "Location 6"]
707 #[inline(always)]
708 pub fn loc6(self) -> &'a mut W {
709 self.variant(CH3LOC_A::LOC6)
710 }
711 #[doc = "Location 7"]
712 #[inline(always)]
713 pub fn loc7(self) -> &'a mut W {
714 self.variant(CH3LOC_A::LOC7)
715 }
716 #[doc = "Location 8"]
717 #[inline(always)]
718 pub fn loc8(self) -> &'a mut W {
719 self.variant(CH3LOC_A::LOC8)
720 }
721 #[doc = "Location 9"]
722 #[inline(always)]
723 pub fn loc9(self) -> &'a mut W {
724 self.variant(CH3LOC_A::LOC9)
725 }
726 #[doc = "Location 10"]
727 #[inline(always)]
728 pub fn loc10(self) -> &'a mut W {
729 self.variant(CH3LOC_A::LOC10)
730 }
731 #[doc = "Location 11"]
732 #[inline(always)]
733 pub fn loc11(self) -> &'a mut W {
734 self.variant(CH3LOC_A::LOC11)
735 }
736 #[doc = "Location 12"]
737 #[inline(always)]
738 pub fn loc12(self) -> &'a mut W {
739 self.variant(CH3LOC_A::LOC12)
740 }
741 #[doc = "Location 13"]
742 #[inline(always)]
743 pub fn loc13(self) -> &'a mut W {
744 self.variant(CH3LOC_A::LOC13)
745 }
746 #[doc = "Location 14"]
747 #[inline(always)]
748 pub fn loc14(self) -> &'a mut W {
749 self.variant(CH3LOC_A::LOC14)
750 }
751 #[doc = r"Writes raw bits to the field"]
752 #[inline(always)]
753 pub unsafe fn bits(self, value: u8) -> &'a mut W {
754 self.w.bits = (self.w.bits & !(0x3f << 24)) | (((value as u32) & 0x3f) << 24);
755 self.w
756 }
757}
758impl R {
759 #[doc = "Bits 0:5 - I/O Location"]
760 #[inline(always)]
761 pub fn ch0loc(&self) -> CH0LOC_R {
762 CH0LOC_R::new((self.bits & 0x3f) as u8)
763 }
764 #[doc = "Bits 8:13 - I/O Location"]
765 #[inline(always)]
766 pub fn ch1loc(&self) -> CH1LOC_R {
767 CH1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
768 }
769 #[doc = "Bits 16:21 - I/O Location"]
770 #[inline(always)]
771 pub fn ch2loc(&self) -> CH2LOC_R {
772 CH2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
773 }
774 #[doc = "Bits 24:29 - I/O Location"]
775 #[inline(always)]
776 pub fn ch3loc(&self) -> CH3LOC_R {
777 CH3LOC_R::new(((self.bits >> 24) & 0x3f) as u8)
778 }
779}
780impl W {
781 #[doc = "Bits 0:5 - I/O Location"]
782 #[inline(always)]
783 pub fn ch0loc(&mut self) -> CH0LOC_W {
784 CH0LOC_W { w: self }
785 }
786 #[doc = "Bits 8:13 - I/O Location"]
787 #[inline(always)]
788 pub fn ch1loc(&mut self) -> CH1LOC_W {
789 CH1LOC_W { w: self }
790 }
791 #[doc = "Bits 16:21 - I/O Location"]
792 #[inline(always)]
793 pub fn ch2loc(&mut self) -> CH2LOC_W {
794 CH2LOC_W { w: self }
795 }
796 #[doc = "Bits 24:29 - I/O Location"]
797 #[inline(always)]
798 pub fn ch3loc(&mut self) -> CH3LOC_W {
799 CH3LOC_W { w: self }
800 }
801}