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