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 CDTI0LOC_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 #[doc = "14: Location 14"]
46 LOC14 = 14,
47 #[doc = "15: Location 15"]
48 LOC15 = 15,
49 #[doc = "16: Location 16"]
50 LOC16 = 16,
51 #[doc = "17: Location 17"]
52 LOC17 = 17,
53 #[doc = "18: Location 18"]
54 LOC18 = 18,
55 #[doc = "19: Location 19"]
56 LOC19 = 19,
57 #[doc = "20: Location 20"]
58 LOC20 = 20,
59 #[doc = "21: Location 21"]
60 LOC21 = 21,
61 #[doc = "22: Location 22"]
62 LOC22 = 22,
63 #[doc = "23: Location 23"]
64 LOC23 = 23,
65 #[doc = "24: Location 24"]
66 LOC24 = 24,
67 #[doc = "25: Location 25"]
68 LOC25 = 25,
69 #[doc = "26: Location 26"]
70 LOC26 = 26,
71 #[doc = "27: Location 27"]
72 LOC27 = 27,
73 #[doc = "28: Location 28"]
74 LOC28 = 28,
75 #[doc = "29: Location 29"]
76 LOC29 = 29,
77 #[doc = "30: Location 30"]
78 LOC30 = 30,
79 #[doc = "31: Location 31"]
80 LOC31 = 31,
81}
82impl From<CDTI0LOC_A> for u8 {
83 #[inline(always)]
84 fn from(variant: CDTI0LOC_A) -> Self {
85 variant as _
86 }
87}
88#[doc = "Reader of field `CDTI0LOC`"]
89pub type CDTI0LOC_R = crate::R<u8, CDTI0LOC_A>;
90impl CDTI0LOC_R {
91 #[doc = r"Get enumerated values variant"]
92 #[inline(always)]
93 pub fn variant(&self) -> crate::Variant<u8, CDTI0LOC_A> {
94 use crate::Variant::*;
95 match self.bits {
96 0 => Val(CDTI0LOC_A::LOC0),
97 1 => Val(CDTI0LOC_A::LOC1),
98 2 => Val(CDTI0LOC_A::LOC2),
99 3 => Val(CDTI0LOC_A::LOC3),
100 4 => Val(CDTI0LOC_A::LOC4),
101 5 => Val(CDTI0LOC_A::LOC5),
102 6 => Val(CDTI0LOC_A::LOC6),
103 7 => Val(CDTI0LOC_A::LOC7),
104 8 => Val(CDTI0LOC_A::LOC8),
105 9 => Val(CDTI0LOC_A::LOC9),
106 10 => Val(CDTI0LOC_A::LOC10),
107 11 => Val(CDTI0LOC_A::LOC11),
108 12 => Val(CDTI0LOC_A::LOC12),
109 13 => Val(CDTI0LOC_A::LOC13),
110 14 => Val(CDTI0LOC_A::LOC14),
111 15 => Val(CDTI0LOC_A::LOC15),
112 16 => Val(CDTI0LOC_A::LOC16),
113 17 => Val(CDTI0LOC_A::LOC17),
114 18 => Val(CDTI0LOC_A::LOC18),
115 19 => Val(CDTI0LOC_A::LOC19),
116 20 => Val(CDTI0LOC_A::LOC20),
117 21 => Val(CDTI0LOC_A::LOC21),
118 22 => Val(CDTI0LOC_A::LOC22),
119 23 => Val(CDTI0LOC_A::LOC23),
120 24 => Val(CDTI0LOC_A::LOC24),
121 25 => Val(CDTI0LOC_A::LOC25),
122 26 => Val(CDTI0LOC_A::LOC26),
123 27 => Val(CDTI0LOC_A::LOC27),
124 28 => Val(CDTI0LOC_A::LOC28),
125 29 => Val(CDTI0LOC_A::LOC29),
126 30 => Val(CDTI0LOC_A::LOC30),
127 31 => Val(CDTI0LOC_A::LOC31),
128 i => Res(i),
129 }
130 }
131 #[doc = "Checks if the value of the field is `LOC0`"]
132 #[inline(always)]
133 pub fn is_loc0(&self) -> bool {
134 *self == CDTI0LOC_A::LOC0
135 }
136 #[doc = "Checks if the value of the field is `LOC1`"]
137 #[inline(always)]
138 pub fn is_loc1(&self) -> bool {
139 *self == CDTI0LOC_A::LOC1
140 }
141 #[doc = "Checks if the value of the field is `LOC2`"]
142 #[inline(always)]
143 pub fn is_loc2(&self) -> bool {
144 *self == CDTI0LOC_A::LOC2
145 }
146 #[doc = "Checks if the value of the field is `LOC3`"]
147 #[inline(always)]
148 pub fn is_loc3(&self) -> bool {
149 *self == CDTI0LOC_A::LOC3
150 }
151 #[doc = "Checks if the value of the field is `LOC4`"]
152 #[inline(always)]
153 pub fn is_loc4(&self) -> bool {
154 *self == CDTI0LOC_A::LOC4
155 }
156 #[doc = "Checks if the value of the field is `LOC5`"]
157 #[inline(always)]
158 pub fn is_loc5(&self) -> bool {
159 *self == CDTI0LOC_A::LOC5
160 }
161 #[doc = "Checks if the value of the field is `LOC6`"]
162 #[inline(always)]
163 pub fn is_loc6(&self) -> bool {
164 *self == CDTI0LOC_A::LOC6
165 }
166 #[doc = "Checks if the value of the field is `LOC7`"]
167 #[inline(always)]
168 pub fn is_loc7(&self) -> bool {
169 *self == CDTI0LOC_A::LOC7
170 }
171 #[doc = "Checks if the value of the field is `LOC8`"]
172 #[inline(always)]
173 pub fn is_loc8(&self) -> bool {
174 *self == CDTI0LOC_A::LOC8
175 }
176 #[doc = "Checks if the value of the field is `LOC9`"]
177 #[inline(always)]
178 pub fn is_loc9(&self) -> bool {
179 *self == CDTI0LOC_A::LOC9
180 }
181 #[doc = "Checks if the value of the field is `LOC10`"]
182 #[inline(always)]
183 pub fn is_loc10(&self) -> bool {
184 *self == CDTI0LOC_A::LOC10
185 }
186 #[doc = "Checks if the value of the field is `LOC11`"]
187 #[inline(always)]
188 pub fn is_loc11(&self) -> bool {
189 *self == CDTI0LOC_A::LOC11
190 }
191 #[doc = "Checks if the value of the field is `LOC12`"]
192 #[inline(always)]
193 pub fn is_loc12(&self) -> bool {
194 *self == CDTI0LOC_A::LOC12
195 }
196 #[doc = "Checks if the value of the field is `LOC13`"]
197 #[inline(always)]
198 pub fn is_loc13(&self) -> bool {
199 *self == CDTI0LOC_A::LOC13
200 }
201 #[doc = "Checks if the value of the field is `LOC14`"]
202 #[inline(always)]
203 pub fn is_loc14(&self) -> bool {
204 *self == CDTI0LOC_A::LOC14
205 }
206 #[doc = "Checks if the value of the field is `LOC15`"]
207 #[inline(always)]
208 pub fn is_loc15(&self) -> bool {
209 *self == CDTI0LOC_A::LOC15
210 }
211 #[doc = "Checks if the value of the field is `LOC16`"]
212 #[inline(always)]
213 pub fn is_loc16(&self) -> bool {
214 *self == CDTI0LOC_A::LOC16
215 }
216 #[doc = "Checks if the value of the field is `LOC17`"]
217 #[inline(always)]
218 pub fn is_loc17(&self) -> bool {
219 *self == CDTI0LOC_A::LOC17
220 }
221 #[doc = "Checks if the value of the field is `LOC18`"]
222 #[inline(always)]
223 pub fn is_loc18(&self) -> bool {
224 *self == CDTI0LOC_A::LOC18
225 }
226 #[doc = "Checks if the value of the field is `LOC19`"]
227 #[inline(always)]
228 pub fn is_loc19(&self) -> bool {
229 *self == CDTI0LOC_A::LOC19
230 }
231 #[doc = "Checks if the value of the field is `LOC20`"]
232 #[inline(always)]
233 pub fn is_loc20(&self) -> bool {
234 *self == CDTI0LOC_A::LOC20
235 }
236 #[doc = "Checks if the value of the field is `LOC21`"]
237 #[inline(always)]
238 pub fn is_loc21(&self) -> bool {
239 *self == CDTI0LOC_A::LOC21
240 }
241 #[doc = "Checks if the value of the field is `LOC22`"]
242 #[inline(always)]
243 pub fn is_loc22(&self) -> bool {
244 *self == CDTI0LOC_A::LOC22
245 }
246 #[doc = "Checks if the value of the field is `LOC23`"]
247 #[inline(always)]
248 pub fn is_loc23(&self) -> bool {
249 *self == CDTI0LOC_A::LOC23
250 }
251 #[doc = "Checks if the value of the field is `LOC24`"]
252 #[inline(always)]
253 pub fn is_loc24(&self) -> bool {
254 *self == CDTI0LOC_A::LOC24
255 }
256 #[doc = "Checks if the value of the field is `LOC25`"]
257 #[inline(always)]
258 pub fn is_loc25(&self) -> bool {
259 *self == CDTI0LOC_A::LOC25
260 }
261 #[doc = "Checks if the value of the field is `LOC26`"]
262 #[inline(always)]
263 pub fn is_loc26(&self) -> bool {
264 *self == CDTI0LOC_A::LOC26
265 }
266 #[doc = "Checks if the value of the field is `LOC27`"]
267 #[inline(always)]
268 pub fn is_loc27(&self) -> bool {
269 *self == CDTI0LOC_A::LOC27
270 }
271 #[doc = "Checks if the value of the field is `LOC28`"]
272 #[inline(always)]
273 pub fn is_loc28(&self) -> bool {
274 *self == CDTI0LOC_A::LOC28
275 }
276 #[doc = "Checks if the value of the field is `LOC29`"]
277 #[inline(always)]
278 pub fn is_loc29(&self) -> bool {
279 *self == CDTI0LOC_A::LOC29
280 }
281 #[doc = "Checks if the value of the field is `LOC30`"]
282 #[inline(always)]
283 pub fn is_loc30(&self) -> bool {
284 *self == CDTI0LOC_A::LOC30
285 }
286 #[doc = "Checks if the value of the field is `LOC31`"]
287 #[inline(always)]
288 pub fn is_loc31(&self) -> bool {
289 *self == CDTI0LOC_A::LOC31
290 }
291}
292#[doc = "Write proxy for field `CDTI0LOC`"]
293pub struct CDTI0LOC_W<'a> {
294 w: &'a mut W,
295}
296impl<'a> CDTI0LOC_W<'a> {
297 #[doc = r"Writes `variant` to the field"]
298 #[inline(always)]
299 pub fn variant(self, variant: CDTI0LOC_A) -> &'a mut W {
300 unsafe { self.bits(variant.into()) }
301 }
302 #[doc = "Location 0"]
303 #[inline(always)]
304 pub fn loc0(self) -> &'a mut W {
305 self.variant(CDTI0LOC_A::LOC0)
306 }
307 #[doc = "Location 1"]
308 #[inline(always)]
309 pub fn loc1(self) -> &'a mut W {
310 self.variant(CDTI0LOC_A::LOC1)
311 }
312 #[doc = "Location 2"]
313 #[inline(always)]
314 pub fn loc2(self) -> &'a mut W {
315 self.variant(CDTI0LOC_A::LOC2)
316 }
317 #[doc = "Location 3"]
318 #[inline(always)]
319 pub fn loc3(self) -> &'a mut W {
320 self.variant(CDTI0LOC_A::LOC3)
321 }
322 #[doc = "Location 4"]
323 #[inline(always)]
324 pub fn loc4(self) -> &'a mut W {
325 self.variant(CDTI0LOC_A::LOC4)
326 }
327 #[doc = "Location 5"]
328 #[inline(always)]
329 pub fn loc5(self) -> &'a mut W {
330 self.variant(CDTI0LOC_A::LOC5)
331 }
332 #[doc = "Location 6"]
333 #[inline(always)]
334 pub fn loc6(self) -> &'a mut W {
335 self.variant(CDTI0LOC_A::LOC6)
336 }
337 #[doc = "Location 7"]
338 #[inline(always)]
339 pub fn loc7(self) -> &'a mut W {
340 self.variant(CDTI0LOC_A::LOC7)
341 }
342 #[doc = "Location 8"]
343 #[inline(always)]
344 pub fn loc8(self) -> &'a mut W {
345 self.variant(CDTI0LOC_A::LOC8)
346 }
347 #[doc = "Location 9"]
348 #[inline(always)]
349 pub fn loc9(self) -> &'a mut W {
350 self.variant(CDTI0LOC_A::LOC9)
351 }
352 #[doc = "Location 10"]
353 #[inline(always)]
354 pub fn loc10(self) -> &'a mut W {
355 self.variant(CDTI0LOC_A::LOC10)
356 }
357 #[doc = "Location 11"]
358 #[inline(always)]
359 pub fn loc11(self) -> &'a mut W {
360 self.variant(CDTI0LOC_A::LOC11)
361 }
362 #[doc = "Location 12"]
363 #[inline(always)]
364 pub fn loc12(self) -> &'a mut W {
365 self.variant(CDTI0LOC_A::LOC12)
366 }
367 #[doc = "Location 13"]
368 #[inline(always)]
369 pub fn loc13(self) -> &'a mut W {
370 self.variant(CDTI0LOC_A::LOC13)
371 }
372 #[doc = "Location 14"]
373 #[inline(always)]
374 pub fn loc14(self) -> &'a mut W {
375 self.variant(CDTI0LOC_A::LOC14)
376 }
377 #[doc = "Location 15"]
378 #[inline(always)]
379 pub fn loc15(self) -> &'a mut W {
380 self.variant(CDTI0LOC_A::LOC15)
381 }
382 #[doc = "Location 16"]
383 #[inline(always)]
384 pub fn loc16(self) -> &'a mut W {
385 self.variant(CDTI0LOC_A::LOC16)
386 }
387 #[doc = "Location 17"]
388 #[inline(always)]
389 pub fn loc17(self) -> &'a mut W {
390 self.variant(CDTI0LOC_A::LOC17)
391 }
392 #[doc = "Location 18"]
393 #[inline(always)]
394 pub fn loc18(self) -> &'a mut W {
395 self.variant(CDTI0LOC_A::LOC18)
396 }
397 #[doc = "Location 19"]
398 #[inline(always)]
399 pub fn loc19(self) -> &'a mut W {
400 self.variant(CDTI0LOC_A::LOC19)
401 }
402 #[doc = "Location 20"]
403 #[inline(always)]
404 pub fn loc20(self) -> &'a mut W {
405 self.variant(CDTI0LOC_A::LOC20)
406 }
407 #[doc = "Location 21"]
408 #[inline(always)]
409 pub fn loc21(self) -> &'a mut W {
410 self.variant(CDTI0LOC_A::LOC21)
411 }
412 #[doc = "Location 22"]
413 #[inline(always)]
414 pub fn loc22(self) -> &'a mut W {
415 self.variant(CDTI0LOC_A::LOC22)
416 }
417 #[doc = "Location 23"]
418 #[inline(always)]
419 pub fn loc23(self) -> &'a mut W {
420 self.variant(CDTI0LOC_A::LOC23)
421 }
422 #[doc = "Location 24"]
423 #[inline(always)]
424 pub fn loc24(self) -> &'a mut W {
425 self.variant(CDTI0LOC_A::LOC24)
426 }
427 #[doc = "Location 25"]
428 #[inline(always)]
429 pub fn loc25(self) -> &'a mut W {
430 self.variant(CDTI0LOC_A::LOC25)
431 }
432 #[doc = "Location 26"]
433 #[inline(always)]
434 pub fn loc26(self) -> &'a mut W {
435 self.variant(CDTI0LOC_A::LOC26)
436 }
437 #[doc = "Location 27"]
438 #[inline(always)]
439 pub fn loc27(self) -> &'a mut W {
440 self.variant(CDTI0LOC_A::LOC27)
441 }
442 #[doc = "Location 28"]
443 #[inline(always)]
444 pub fn loc28(self) -> &'a mut W {
445 self.variant(CDTI0LOC_A::LOC28)
446 }
447 #[doc = "Location 29"]
448 #[inline(always)]
449 pub fn loc29(self) -> &'a mut W {
450 self.variant(CDTI0LOC_A::LOC29)
451 }
452 #[doc = "Location 30"]
453 #[inline(always)]
454 pub fn loc30(self) -> &'a mut W {
455 self.variant(CDTI0LOC_A::LOC30)
456 }
457 #[doc = "Location 31"]
458 #[inline(always)]
459 pub fn loc31(self) -> &'a mut W {
460 self.variant(CDTI0LOC_A::LOC31)
461 }
462 #[doc = r"Writes raw bits to the field"]
463 #[inline(always)]
464 pub unsafe fn bits(self, value: u8) -> &'a mut W {
465 self.w.bits = (self.w.bits & !0x3f) | ((value as u32) & 0x3f);
466 self.w
467 }
468}
469#[doc = "I/O Location\n\nValue on reset: 0"]
470#[derive(Clone, Copy, Debug, PartialEq)]
471#[repr(u8)]
472pub enum CDTI1LOC_A {
473 #[doc = "0: Location 0"]
474 LOC0 = 0,
475 #[doc = "1: Location 1"]
476 LOC1 = 1,
477 #[doc = "2: Location 2"]
478 LOC2 = 2,
479 #[doc = "3: Location 3"]
480 LOC3 = 3,
481 #[doc = "4: Location 4"]
482 LOC4 = 4,
483 #[doc = "5: Location 5"]
484 LOC5 = 5,
485 #[doc = "6: Location 6"]
486 LOC6 = 6,
487 #[doc = "7: Location 7"]
488 LOC7 = 7,
489 #[doc = "8: Location 8"]
490 LOC8 = 8,
491 #[doc = "9: Location 9"]
492 LOC9 = 9,
493 #[doc = "10: Location 10"]
494 LOC10 = 10,
495 #[doc = "11: Location 11"]
496 LOC11 = 11,
497 #[doc = "12: Location 12"]
498 LOC12 = 12,
499 #[doc = "13: Location 13"]
500 LOC13 = 13,
501 #[doc = "14: Location 14"]
502 LOC14 = 14,
503 #[doc = "15: Location 15"]
504 LOC15 = 15,
505 #[doc = "16: Location 16"]
506 LOC16 = 16,
507 #[doc = "17: Location 17"]
508 LOC17 = 17,
509 #[doc = "18: Location 18"]
510 LOC18 = 18,
511 #[doc = "19: Location 19"]
512 LOC19 = 19,
513 #[doc = "20: Location 20"]
514 LOC20 = 20,
515 #[doc = "21: Location 21"]
516 LOC21 = 21,
517 #[doc = "22: Location 22"]
518 LOC22 = 22,
519 #[doc = "23: Location 23"]
520 LOC23 = 23,
521 #[doc = "24: Location 24"]
522 LOC24 = 24,
523 #[doc = "25: Location 25"]
524 LOC25 = 25,
525 #[doc = "26: Location 26"]
526 LOC26 = 26,
527 #[doc = "27: Location 27"]
528 LOC27 = 27,
529 #[doc = "28: Location 28"]
530 LOC28 = 28,
531 #[doc = "29: Location 29"]
532 LOC29 = 29,
533 #[doc = "30: Location 30"]
534 LOC30 = 30,
535 #[doc = "31: Location 31"]
536 LOC31 = 31,
537}
538impl From<CDTI1LOC_A> for u8 {
539 #[inline(always)]
540 fn from(variant: CDTI1LOC_A) -> Self {
541 variant as _
542 }
543}
544#[doc = "Reader of field `CDTI1LOC`"]
545pub type CDTI1LOC_R = crate::R<u8, CDTI1LOC_A>;
546impl CDTI1LOC_R {
547 #[doc = r"Get enumerated values variant"]
548 #[inline(always)]
549 pub fn variant(&self) -> crate::Variant<u8, CDTI1LOC_A> {
550 use crate::Variant::*;
551 match self.bits {
552 0 => Val(CDTI1LOC_A::LOC0),
553 1 => Val(CDTI1LOC_A::LOC1),
554 2 => Val(CDTI1LOC_A::LOC2),
555 3 => Val(CDTI1LOC_A::LOC3),
556 4 => Val(CDTI1LOC_A::LOC4),
557 5 => Val(CDTI1LOC_A::LOC5),
558 6 => Val(CDTI1LOC_A::LOC6),
559 7 => Val(CDTI1LOC_A::LOC7),
560 8 => Val(CDTI1LOC_A::LOC8),
561 9 => Val(CDTI1LOC_A::LOC9),
562 10 => Val(CDTI1LOC_A::LOC10),
563 11 => Val(CDTI1LOC_A::LOC11),
564 12 => Val(CDTI1LOC_A::LOC12),
565 13 => Val(CDTI1LOC_A::LOC13),
566 14 => Val(CDTI1LOC_A::LOC14),
567 15 => Val(CDTI1LOC_A::LOC15),
568 16 => Val(CDTI1LOC_A::LOC16),
569 17 => Val(CDTI1LOC_A::LOC17),
570 18 => Val(CDTI1LOC_A::LOC18),
571 19 => Val(CDTI1LOC_A::LOC19),
572 20 => Val(CDTI1LOC_A::LOC20),
573 21 => Val(CDTI1LOC_A::LOC21),
574 22 => Val(CDTI1LOC_A::LOC22),
575 23 => Val(CDTI1LOC_A::LOC23),
576 24 => Val(CDTI1LOC_A::LOC24),
577 25 => Val(CDTI1LOC_A::LOC25),
578 26 => Val(CDTI1LOC_A::LOC26),
579 27 => Val(CDTI1LOC_A::LOC27),
580 28 => Val(CDTI1LOC_A::LOC28),
581 29 => Val(CDTI1LOC_A::LOC29),
582 30 => Val(CDTI1LOC_A::LOC30),
583 31 => Val(CDTI1LOC_A::LOC31),
584 i => Res(i),
585 }
586 }
587 #[doc = "Checks if the value of the field is `LOC0`"]
588 #[inline(always)]
589 pub fn is_loc0(&self) -> bool {
590 *self == CDTI1LOC_A::LOC0
591 }
592 #[doc = "Checks if the value of the field is `LOC1`"]
593 #[inline(always)]
594 pub fn is_loc1(&self) -> bool {
595 *self == CDTI1LOC_A::LOC1
596 }
597 #[doc = "Checks if the value of the field is `LOC2`"]
598 #[inline(always)]
599 pub fn is_loc2(&self) -> bool {
600 *self == CDTI1LOC_A::LOC2
601 }
602 #[doc = "Checks if the value of the field is `LOC3`"]
603 #[inline(always)]
604 pub fn is_loc3(&self) -> bool {
605 *self == CDTI1LOC_A::LOC3
606 }
607 #[doc = "Checks if the value of the field is `LOC4`"]
608 #[inline(always)]
609 pub fn is_loc4(&self) -> bool {
610 *self == CDTI1LOC_A::LOC4
611 }
612 #[doc = "Checks if the value of the field is `LOC5`"]
613 #[inline(always)]
614 pub fn is_loc5(&self) -> bool {
615 *self == CDTI1LOC_A::LOC5
616 }
617 #[doc = "Checks if the value of the field is `LOC6`"]
618 #[inline(always)]
619 pub fn is_loc6(&self) -> bool {
620 *self == CDTI1LOC_A::LOC6
621 }
622 #[doc = "Checks if the value of the field is `LOC7`"]
623 #[inline(always)]
624 pub fn is_loc7(&self) -> bool {
625 *self == CDTI1LOC_A::LOC7
626 }
627 #[doc = "Checks if the value of the field is `LOC8`"]
628 #[inline(always)]
629 pub fn is_loc8(&self) -> bool {
630 *self == CDTI1LOC_A::LOC8
631 }
632 #[doc = "Checks if the value of the field is `LOC9`"]
633 #[inline(always)]
634 pub fn is_loc9(&self) -> bool {
635 *self == CDTI1LOC_A::LOC9
636 }
637 #[doc = "Checks if the value of the field is `LOC10`"]
638 #[inline(always)]
639 pub fn is_loc10(&self) -> bool {
640 *self == CDTI1LOC_A::LOC10
641 }
642 #[doc = "Checks if the value of the field is `LOC11`"]
643 #[inline(always)]
644 pub fn is_loc11(&self) -> bool {
645 *self == CDTI1LOC_A::LOC11
646 }
647 #[doc = "Checks if the value of the field is `LOC12`"]
648 #[inline(always)]
649 pub fn is_loc12(&self) -> bool {
650 *self == CDTI1LOC_A::LOC12
651 }
652 #[doc = "Checks if the value of the field is `LOC13`"]
653 #[inline(always)]
654 pub fn is_loc13(&self) -> bool {
655 *self == CDTI1LOC_A::LOC13
656 }
657 #[doc = "Checks if the value of the field is `LOC14`"]
658 #[inline(always)]
659 pub fn is_loc14(&self) -> bool {
660 *self == CDTI1LOC_A::LOC14
661 }
662 #[doc = "Checks if the value of the field is `LOC15`"]
663 #[inline(always)]
664 pub fn is_loc15(&self) -> bool {
665 *self == CDTI1LOC_A::LOC15
666 }
667 #[doc = "Checks if the value of the field is `LOC16`"]
668 #[inline(always)]
669 pub fn is_loc16(&self) -> bool {
670 *self == CDTI1LOC_A::LOC16
671 }
672 #[doc = "Checks if the value of the field is `LOC17`"]
673 #[inline(always)]
674 pub fn is_loc17(&self) -> bool {
675 *self == CDTI1LOC_A::LOC17
676 }
677 #[doc = "Checks if the value of the field is `LOC18`"]
678 #[inline(always)]
679 pub fn is_loc18(&self) -> bool {
680 *self == CDTI1LOC_A::LOC18
681 }
682 #[doc = "Checks if the value of the field is `LOC19`"]
683 #[inline(always)]
684 pub fn is_loc19(&self) -> bool {
685 *self == CDTI1LOC_A::LOC19
686 }
687 #[doc = "Checks if the value of the field is `LOC20`"]
688 #[inline(always)]
689 pub fn is_loc20(&self) -> bool {
690 *self == CDTI1LOC_A::LOC20
691 }
692 #[doc = "Checks if the value of the field is `LOC21`"]
693 #[inline(always)]
694 pub fn is_loc21(&self) -> bool {
695 *self == CDTI1LOC_A::LOC21
696 }
697 #[doc = "Checks if the value of the field is `LOC22`"]
698 #[inline(always)]
699 pub fn is_loc22(&self) -> bool {
700 *self == CDTI1LOC_A::LOC22
701 }
702 #[doc = "Checks if the value of the field is `LOC23`"]
703 #[inline(always)]
704 pub fn is_loc23(&self) -> bool {
705 *self == CDTI1LOC_A::LOC23
706 }
707 #[doc = "Checks if the value of the field is `LOC24`"]
708 #[inline(always)]
709 pub fn is_loc24(&self) -> bool {
710 *self == CDTI1LOC_A::LOC24
711 }
712 #[doc = "Checks if the value of the field is `LOC25`"]
713 #[inline(always)]
714 pub fn is_loc25(&self) -> bool {
715 *self == CDTI1LOC_A::LOC25
716 }
717 #[doc = "Checks if the value of the field is `LOC26`"]
718 #[inline(always)]
719 pub fn is_loc26(&self) -> bool {
720 *self == CDTI1LOC_A::LOC26
721 }
722 #[doc = "Checks if the value of the field is `LOC27`"]
723 #[inline(always)]
724 pub fn is_loc27(&self) -> bool {
725 *self == CDTI1LOC_A::LOC27
726 }
727 #[doc = "Checks if the value of the field is `LOC28`"]
728 #[inline(always)]
729 pub fn is_loc28(&self) -> bool {
730 *self == CDTI1LOC_A::LOC28
731 }
732 #[doc = "Checks if the value of the field is `LOC29`"]
733 #[inline(always)]
734 pub fn is_loc29(&self) -> bool {
735 *self == CDTI1LOC_A::LOC29
736 }
737 #[doc = "Checks if the value of the field is `LOC30`"]
738 #[inline(always)]
739 pub fn is_loc30(&self) -> bool {
740 *self == CDTI1LOC_A::LOC30
741 }
742 #[doc = "Checks if the value of the field is `LOC31`"]
743 #[inline(always)]
744 pub fn is_loc31(&self) -> bool {
745 *self == CDTI1LOC_A::LOC31
746 }
747}
748#[doc = "Write proxy for field `CDTI1LOC`"]
749pub struct CDTI1LOC_W<'a> {
750 w: &'a mut W,
751}
752impl<'a> CDTI1LOC_W<'a> {
753 #[doc = r"Writes `variant` to the field"]
754 #[inline(always)]
755 pub fn variant(self, variant: CDTI1LOC_A) -> &'a mut W {
756 unsafe { self.bits(variant.into()) }
757 }
758 #[doc = "Location 0"]
759 #[inline(always)]
760 pub fn loc0(self) -> &'a mut W {
761 self.variant(CDTI1LOC_A::LOC0)
762 }
763 #[doc = "Location 1"]
764 #[inline(always)]
765 pub fn loc1(self) -> &'a mut W {
766 self.variant(CDTI1LOC_A::LOC1)
767 }
768 #[doc = "Location 2"]
769 #[inline(always)]
770 pub fn loc2(self) -> &'a mut W {
771 self.variant(CDTI1LOC_A::LOC2)
772 }
773 #[doc = "Location 3"]
774 #[inline(always)]
775 pub fn loc3(self) -> &'a mut W {
776 self.variant(CDTI1LOC_A::LOC3)
777 }
778 #[doc = "Location 4"]
779 #[inline(always)]
780 pub fn loc4(self) -> &'a mut W {
781 self.variant(CDTI1LOC_A::LOC4)
782 }
783 #[doc = "Location 5"]
784 #[inline(always)]
785 pub fn loc5(self) -> &'a mut W {
786 self.variant(CDTI1LOC_A::LOC5)
787 }
788 #[doc = "Location 6"]
789 #[inline(always)]
790 pub fn loc6(self) -> &'a mut W {
791 self.variant(CDTI1LOC_A::LOC6)
792 }
793 #[doc = "Location 7"]
794 #[inline(always)]
795 pub fn loc7(self) -> &'a mut W {
796 self.variant(CDTI1LOC_A::LOC7)
797 }
798 #[doc = "Location 8"]
799 #[inline(always)]
800 pub fn loc8(self) -> &'a mut W {
801 self.variant(CDTI1LOC_A::LOC8)
802 }
803 #[doc = "Location 9"]
804 #[inline(always)]
805 pub fn loc9(self) -> &'a mut W {
806 self.variant(CDTI1LOC_A::LOC9)
807 }
808 #[doc = "Location 10"]
809 #[inline(always)]
810 pub fn loc10(self) -> &'a mut W {
811 self.variant(CDTI1LOC_A::LOC10)
812 }
813 #[doc = "Location 11"]
814 #[inline(always)]
815 pub fn loc11(self) -> &'a mut W {
816 self.variant(CDTI1LOC_A::LOC11)
817 }
818 #[doc = "Location 12"]
819 #[inline(always)]
820 pub fn loc12(self) -> &'a mut W {
821 self.variant(CDTI1LOC_A::LOC12)
822 }
823 #[doc = "Location 13"]
824 #[inline(always)]
825 pub fn loc13(self) -> &'a mut W {
826 self.variant(CDTI1LOC_A::LOC13)
827 }
828 #[doc = "Location 14"]
829 #[inline(always)]
830 pub fn loc14(self) -> &'a mut W {
831 self.variant(CDTI1LOC_A::LOC14)
832 }
833 #[doc = "Location 15"]
834 #[inline(always)]
835 pub fn loc15(self) -> &'a mut W {
836 self.variant(CDTI1LOC_A::LOC15)
837 }
838 #[doc = "Location 16"]
839 #[inline(always)]
840 pub fn loc16(self) -> &'a mut W {
841 self.variant(CDTI1LOC_A::LOC16)
842 }
843 #[doc = "Location 17"]
844 #[inline(always)]
845 pub fn loc17(self) -> &'a mut W {
846 self.variant(CDTI1LOC_A::LOC17)
847 }
848 #[doc = "Location 18"]
849 #[inline(always)]
850 pub fn loc18(self) -> &'a mut W {
851 self.variant(CDTI1LOC_A::LOC18)
852 }
853 #[doc = "Location 19"]
854 #[inline(always)]
855 pub fn loc19(self) -> &'a mut W {
856 self.variant(CDTI1LOC_A::LOC19)
857 }
858 #[doc = "Location 20"]
859 #[inline(always)]
860 pub fn loc20(self) -> &'a mut W {
861 self.variant(CDTI1LOC_A::LOC20)
862 }
863 #[doc = "Location 21"]
864 #[inline(always)]
865 pub fn loc21(self) -> &'a mut W {
866 self.variant(CDTI1LOC_A::LOC21)
867 }
868 #[doc = "Location 22"]
869 #[inline(always)]
870 pub fn loc22(self) -> &'a mut W {
871 self.variant(CDTI1LOC_A::LOC22)
872 }
873 #[doc = "Location 23"]
874 #[inline(always)]
875 pub fn loc23(self) -> &'a mut W {
876 self.variant(CDTI1LOC_A::LOC23)
877 }
878 #[doc = "Location 24"]
879 #[inline(always)]
880 pub fn loc24(self) -> &'a mut W {
881 self.variant(CDTI1LOC_A::LOC24)
882 }
883 #[doc = "Location 25"]
884 #[inline(always)]
885 pub fn loc25(self) -> &'a mut W {
886 self.variant(CDTI1LOC_A::LOC25)
887 }
888 #[doc = "Location 26"]
889 #[inline(always)]
890 pub fn loc26(self) -> &'a mut W {
891 self.variant(CDTI1LOC_A::LOC26)
892 }
893 #[doc = "Location 27"]
894 #[inline(always)]
895 pub fn loc27(self) -> &'a mut W {
896 self.variant(CDTI1LOC_A::LOC27)
897 }
898 #[doc = "Location 28"]
899 #[inline(always)]
900 pub fn loc28(self) -> &'a mut W {
901 self.variant(CDTI1LOC_A::LOC28)
902 }
903 #[doc = "Location 29"]
904 #[inline(always)]
905 pub fn loc29(self) -> &'a mut W {
906 self.variant(CDTI1LOC_A::LOC29)
907 }
908 #[doc = "Location 30"]
909 #[inline(always)]
910 pub fn loc30(self) -> &'a mut W {
911 self.variant(CDTI1LOC_A::LOC30)
912 }
913 #[doc = "Location 31"]
914 #[inline(always)]
915 pub fn loc31(self) -> &'a mut W {
916 self.variant(CDTI1LOC_A::LOC31)
917 }
918 #[doc = r"Writes raw bits to the field"]
919 #[inline(always)]
920 pub unsafe fn bits(self, value: u8) -> &'a mut W {
921 self.w.bits = (self.w.bits & !(0x3f << 8)) | (((value as u32) & 0x3f) << 8);
922 self.w
923 }
924}
925#[doc = "I/O Location\n\nValue on reset: 0"]
926#[derive(Clone, Copy, Debug, PartialEq)]
927#[repr(u8)]
928pub enum CDTI2LOC_A {
929 #[doc = "0: Location 0"]
930 LOC0 = 0,
931 #[doc = "1: Location 1"]
932 LOC1 = 1,
933 #[doc = "2: Location 2"]
934 LOC2 = 2,
935 #[doc = "3: Location 3"]
936 LOC3 = 3,
937 #[doc = "4: Location 4"]
938 LOC4 = 4,
939 #[doc = "5: Location 5"]
940 LOC5 = 5,
941 #[doc = "6: Location 6"]
942 LOC6 = 6,
943 #[doc = "7: Location 7"]
944 LOC7 = 7,
945 #[doc = "8: Location 8"]
946 LOC8 = 8,
947 #[doc = "9: Location 9"]
948 LOC9 = 9,
949 #[doc = "10: Location 10"]
950 LOC10 = 10,
951 #[doc = "11: Location 11"]
952 LOC11 = 11,
953 #[doc = "12: Location 12"]
954 LOC12 = 12,
955 #[doc = "13: Location 13"]
956 LOC13 = 13,
957 #[doc = "14: Location 14"]
958 LOC14 = 14,
959 #[doc = "15: Location 15"]
960 LOC15 = 15,
961 #[doc = "16: Location 16"]
962 LOC16 = 16,
963 #[doc = "17: Location 17"]
964 LOC17 = 17,
965 #[doc = "18: Location 18"]
966 LOC18 = 18,
967 #[doc = "19: Location 19"]
968 LOC19 = 19,
969 #[doc = "20: Location 20"]
970 LOC20 = 20,
971 #[doc = "21: Location 21"]
972 LOC21 = 21,
973 #[doc = "22: Location 22"]
974 LOC22 = 22,
975 #[doc = "23: Location 23"]
976 LOC23 = 23,
977 #[doc = "24: Location 24"]
978 LOC24 = 24,
979 #[doc = "25: Location 25"]
980 LOC25 = 25,
981 #[doc = "26: Location 26"]
982 LOC26 = 26,
983 #[doc = "27: Location 27"]
984 LOC27 = 27,
985 #[doc = "28: Location 28"]
986 LOC28 = 28,
987 #[doc = "29: Location 29"]
988 LOC29 = 29,
989 #[doc = "30: Location 30"]
990 LOC30 = 30,
991 #[doc = "31: Location 31"]
992 LOC31 = 31,
993}
994impl From<CDTI2LOC_A> for u8 {
995 #[inline(always)]
996 fn from(variant: CDTI2LOC_A) -> Self {
997 variant as _
998 }
999}
1000#[doc = "Reader of field `CDTI2LOC`"]
1001pub type CDTI2LOC_R = crate::R<u8, CDTI2LOC_A>;
1002impl CDTI2LOC_R {
1003 #[doc = r"Get enumerated values variant"]
1004 #[inline(always)]
1005 pub fn variant(&self) -> crate::Variant<u8, CDTI2LOC_A> {
1006 use crate::Variant::*;
1007 match self.bits {
1008 0 => Val(CDTI2LOC_A::LOC0),
1009 1 => Val(CDTI2LOC_A::LOC1),
1010 2 => Val(CDTI2LOC_A::LOC2),
1011 3 => Val(CDTI2LOC_A::LOC3),
1012 4 => Val(CDTI2LOC_A::LOC4),
1013 5 => Val(CDTI2LOC_A::LOC5),
1014 6 => Val(CDTI2LOC_A::LOC6),
1015 7 => Val(CDTI2LOC_A::LOC7),
1016 8 => Val(CDTI2LOC_A::LOC8),
1017 9 => Val(CDTI2LOC_A::LOC9),
1018 10 => Val(CDTI2LOC_A::LOC10),
1019 11 => Val(CDTI2LOC_A::LOC11),
1020 12 => Val(CDTI2LOC_A::LOC12),
1021 13 => Val(CDTI2LOC_A::LOC13),
1022 14 => Val(CDTI2LOC_A::LOC14),
1023 15 => Val(CDTI2LOC_A::LOC15),
1024 16 => Val(CDTI2LOC_A::LOC16),
1025 17 => Val(CDTI2LOC_A::LOC17),
1026 18 => Val(CDTI2LOC_A::LOC18),
1027 19 => Val(CDTI2LOC_A::LOC19),
1028 20 => Val(CDTI2LOC_A::LOC20),
1029 21 => Val(CDTI2LOC_A::LOC21),
1030 22 => Val(CDTI2LOC_A::LOC22),
1031 23 => Val(CDTI2LOC_A::LOC23),
1032 24 => Val(CDTI2LOC_A::LOC24),
1033 25 => Val(CDTI2LOC_A::LOC25),
1034 26 => Val(CDTI2LOC_A::LOC26),
1035 27 => Val(CDTI2LOC_A::LOC27),
1036 28 => Val(CDTI2LOC_A::LOC28),
1037 29 => Val(CDTI2LOC_A::LOC29),
1038 30 => Val(CDTI2LOC_A::LOC30),
1039 31 => Val(CDTI2LOC_A::LOC31),
1040 i => Res(i),
1041 }
1042 }
1043 #[doc = "Checks if the value of the field is `LOC0`"]
1044 #[inline(always)]
1045 pub fn is_loc0(&self) -> bool {
1046 *self == CDTI2LOC_A::LOC0
1047 }
1048 #[doc = "Checks if the value of the field is `LOC1`"]
1049 #[inline(always)]
1050 pub fn is_loc1(&self) -> bool {
1051 *self == CDTI2LOC_A::LOC1
1052 }
1053 #[doc = "Checks if the value of the field is `LOC2`"]
1054 #[inline(always)]
1055 pub fn is_loc2(&self) -> bool {
1056 *self == CDTI2LOC_A::LOC2
1057 }
1058 #[doc = "Checks if the value of the field is `LOC3`"]
1059 #[inline(always)]
1060 pub fn is_loc3(&self) -> bool {
1061 *self == CDTI2LOC_A::LOC3
1062 }
1063 #[doc = "Checks if the value of the field is `LOC4`"]
1064 #[inline(always)]
1065 pub fn is_loc4(&self) -> bool {
1066 *self == CDTI2LOC_A::LOC4
1067 }
1068 #[doc = "Checks if the value of the field is `LOC5`"]
1069 #[inline(always)]
1070 pub fn is_loc5(&self) -> bool {
1071 *self == CDTI2LOC_A::LOC5
1072 }
1073 #[doc = "Checks if the value of the field is `LOC6`"]
1074 #[inline(always)]
1075 pub fn is_loc6(&self) -> bool {
1076 *self == CDTI2LOC_A::LOC6
1077 }
1078 #[doc = "Checks if the value of the field is `LOC7`"]
1079 #[inline(always)]
1080 pub fn is_loc7(&self) -> bool {
1081 *self == CDTI2LOC_A::LOC7
1082 }
1083 #[doc = "Checks if the value of the field is `LOC8`"]
1084 #[inline(always)]
1085 pub fn is_loc8(&self) -> bool {
1086 *self == CDTI2LOC_A::LOC8
1087 }
1088 #[doc = "Checks if the value of the field is `LOC9`"]
1089 #[inline(always)]
1090 pub fn is_loc9(&self) -> bool {
1091 *self == CDTI2LOC_A::LOC9
1092 }
1093 #[doc = "Checks if the value of the field is `LOC10`"]
1094 #[inline(always)]
1095 pub fn is_loc10(&self) -> bool {
1096 *self == CDTI2LOC_A::LOC10
1097 }
1098 #[doc = "Checks if the value of the field is `LOC11`"]
1099 #[inline(always)]
1100 pub fn is_loc11(&self) -> bool {
1101 *self == CDTI2LOC_A::LOC11
1102 }
1103 #[doc = "Checks if the value of the field is `LOC12`"]
1104 #[inline(always)]
1105 pub fn is_loc12(&self) -> bool {
1106 *self == CDTI2LOC_A::LOC12
1107 }
1108 #[doc = "Checks if the value of the field is `LOC13`"]
1109 #[inline(always)]
1110 pub fn is_loc13(&self) -> bool {
1111 *self == CDTI2LOC_A::LOC13
1112 }
1113 #[doc = "Checks if the value of the field is `LOC14`"]
1114 #[inline(always)]
1115 pub fn is_loc14(&self) -> bool {
1116 *self == CDTI2LOC_A::LOC14
1117 }
1118 #[doc = "Checks if the value of the field is `LOC15`"]
1119 #[inline(always)]
1120 pub fn is_loc15(&self) -> bool {
1121 *self == CDTI2LOC_A::LOC15
1122 }
1123 #[doc = "Checks if the value of the field is `LOC16`"]
1124 #[inline(always)]
1125 pub fn is_loc16(&self) -> bool {
1126 *self == CDTI2LOC_A::LOC16
1127 }
1128 #[doc = "Checks if the value of the field is `LOC17`"]
1129 #[inline(always)]
1130 pub fn is_loc17(&self) -> bool {
1131 *self == CDTI2LOC_A::LOC17
1132 }
1133 #[doc = "Checks if the value of the field is `LOC18`"]
1134 #[inline(always)]
1135 pub fn is_loc18(&self) -> bool {
1136 *self == CDTI2LOC_A::LOC18
1137 }
1138 #[doc = "Checks if the value of the field is `LOC19`"]
1139 #[inline(always)]
1140 pub fn is_loc19(&self) -> bool {
1141 *self == CDTI2LOC_A::LOC19
1142 }
1143 #[doc = "Checks if the value of the field is `LOC20`"]
1144 #[inline(always)]
1145 pub fn is_loc20(&self) -> bool {
1146 *self == CDTI2LOC_A::LOC20
1147 }
1148 #[doc = "Checks if the value of the field is `LOC21`"]
1149 #[inline(always)]
1150 pub fn is_loc21(&self) -> bool {
1151 *self == CDTI2LOC_A::LOC21
1152 }
1153 #[doc = "Checks if the value of the field is `LOC22`"]
1154 #[inline(always)]
1155 pub fn is_loc22(&self) -> bool {
1156 *self == CDTI2LOC_A::LOC22
1157 }
1158 #[doc = "Checks if the value of the field is `LOC23`"]
1159 #[inline(always)]
1160 pub fn is_loc23(&self) -> bool {
1161 *self == CDTI2LOC_A::LOC23
1162 }
1163 #[doc = "Checks if the value of the field is `LOC24`"]
1164 #[inline(always)]
1165 pub fn is_loc24(&self) -> bool {
1166 *self == CDTI2LOC_A::LOC24
1167 }
1168 #[doc = "Checks if the value of the field is `LOC25`"]
1169 #[inline(always)]
1170 pub fn is_loc25(&self) -> bool {
1171 *self == CDTI2LOC_A::LOC25
1172 }
1173 #[doc = "Checks if the value of the field is `LOC26`"]
1174 #[inline(always)]
1175 pub fn is_loc26(&self) -> bool {
1176 *self == CDTI2LOC_A::LOC26
1177 }
1178 #[doc = "Checks if the value of the field is `LOC27`"]
1179 #[inline(always)]
1180 pub fn is_loc27(&self) -> bool {
1181 *self == CDTI2LOC_A::LOC27
1182 }
1183 #[doc = "Checks if the value of the field is `LOC28`"]
1184 #[inline(always)]
1185 pub fn is_loc28(&self) -> bool {
1186 *self == CDTI2LOC_A::LOC28
1187 }
1188 #[doc = "Checks if the value of the field is `LOC29`"]
1189 #[inline(always)]
1190 pub fn is_loc29(&self) -> bool {
1191 *self == CDTI2LOC_A::LOC29
1192 }
1193 #[doc = "Checks if the value of the field is `LOC30`"]
1194 #[inline(always)]
1195 pub fn is_loc30(&self) -> bool {
1196 *self == CDTI2LOC_A::LOC30
1197 }
1198 #[doc = "Checks if the value of the field is `LOC31`"]
1199 #[inline(always)]
1200 pub fn is_loc31(&self) -> bool {
1201 *self == CDTI2LOC_A::LOC31
1202 }
1203}
1204#[doc = "Write proxy for field `CDTI2LOC`"]
1205pub struct CDTI2LOC_W<'a> {
1206 w: &'a mut W,
1207}
1208impl<'a> CDTI2LOC_W<'a> {
1209 #[doc = r"Writes `variant` to the field"]
1210 #[inline(always)]
1211 pub fn variant(self, variant: CDTI2LOC_A) -> &'a mut W {
1212 unsafe { self.bits(variant.into()) }
1213 }
1214 #[doc = "Location 0"]
1215 #[inline(always)]
1216 pub fn loc0(self) -> &'a mut W {
1217 self.variant(CDTI2LOC_A::LOC0)
1218 }
1219 #[doc = "Location 1"]
1220 #[inline(always)]
1221 pub fn loc1(self) -> &'a mut W {
1222 self.variant(CDTI2LOC_A::LOC1)
1223 }
1224 #[doc = "Location 2"]
1225 #[inline(always)]
1226 pub fn loc2(self) -> &'a mut W {
1227 self.variant(CDTI2LOC_A::LOC2)
1228 }
1229 #[doc = "Location 3"]
1230 #[inline(always)]
1231 pub fn loc3(self) -> &'a mut W {
1232 self.variant(CDTI2LOC_A::LOC3)
1233 }
1234 #[doc = "Location 4"]
1235 #[inline(always)]
1236 pub fn loc4(self) -> &'a mut W {
1237 self.variant(CDTI2LOC_A::LOC4)
1238 }
1239 #[doc = "Location 5"]
1240 #[inline(always)]
1241 pub fn loc5(self) -> &'a mut W {
1242 self.variant(CDTI2LOC_A::LOC5)
1243 }
1244 #[doc = "Location 6"]
1245 #[inline(always)]
1246 pub fn loc6(self) -> &'a mut W {
1247 self.variant(CDTI2LOC_A::LOC6)
1248 }
1249 #[doc = "Location 7"]
1250 #[inline(always)]
1251 pub fn loc7(self) -> &'a mut W {
1252 self.variant(CDTI2LOC_A::LOC7)
1253 }
1254 #[doc = "Location 8"]
1255 #[inline(always)]
1256 pub fn loc8(self) -> &'a mut W {
1257 self.variant(CDTI2LOC_A::LOC8)
1258 }
1259 #[doc = "Location 9"]
1260 #[inline(always)]
1261 pub fn loc9(self) -> &'a mut W {
1262 self.variant(CDTI2LOC_A::LOC9)
1263 }
1264 #[doc = "Location 10"]
1265 #[inline(always)]
1266 pub fn loc10(self) -> &'a mut W {
1267 self.variant(CDTI2LOC_A::LOC10)
1268 }
1269 #[doc = "Location 11"]
1270 #[inline(always)]
1271 pub fn loc11(self) -> &'a mut W {
1272 self.variant(CDTI2LOC_A::LOC11)
1273 }
1274 #[doc = "Location 12"]
1275 #[inline(always)]
1276 pub fn loc12(self) -> &'a mut W {
1277 self.variant(CDTI2LOC_A::LOC12)
1278 }
1279 #[doc = "Location 13"]
1280 #[inline(always)]
1281 pub fn loc13(self) -> &'a mut W {
1282 self.variant(CDTI2LOC_A::LOC13)
1283 }
1284 #[doc = "Location 14"]
1285 #[inline(always)]
1286 pub fn loc14(self) -> &'a mut W {
1287 self.variant(CDTI2LOC_A::LOC14)
1288 }
1289 #[doc = "Location 15"]
1290 #[inline(always)]
1291 pub fn loc15(self) -> &'a mut W {
1292 self.variant(CDTI2LOC_A::LOC15)
1293 }
1294 #[doc = "Location 16"]
1295 #[inline(always)]
1296 pub fn loc16(self) -> &'a mut W {
1297 self.variant(CDTI2LOC_A::LOC16)
1298 }
1299 #[doc = "Location 17"]
1300 #[inline(always)]
1301 pub fn loc17(self) -> &'a mut W {
1302 self.variant(CDTI2LOC_A::LOC17)
1303 }
1304 #[doc = "Location 18"]
1305 #[inline(always)]
1306 pub fn loc18(self) -> &'a mut W {
1307 self.variant(CDTI2LOC_A::LOC18)
1308 }
1309 #[doc = "Location 19"]
1310 #[inline(always)]
1311 pub fn loc19(self) -> &'a mut W {
1312 self.variant(CDTI2LOC_A::LOC19)
1313 }
1314 #[doc = "Location 20"]
1315 #[inline(always)]
1316 pub fn loc20(self) -> &'a mut W {
1317 self.variant(CDTI2LOC_A::LOC20)
1318 }
1319 #[doc = "Location 21"]
1320 #[inline(always)]
1321 pub fn loc21(self) -> &'a mut W {
1322 self.variant(CDTI2LOC_A::LOC21)
1323 }
1324 #[doc = "Location 22"]
1325 #[inline(always)]
1326 pub fn loc22(self) -> &'a mut W {
1327 self.variant(CDTI2LOC_A::LOC22)
1328 }
1329 #[doc = "Location 23"]
1330 #[inline(always)]
1331 pub fn loc23(self) -> &'a mut W {
1332 self.variant(CDTI2LOC_A::LOC23)
1333 }
1334 #[doc = "Location 24"]
1335 #[inline(always)]
1336 pub fn loc24(self) -> &'a mut W {
1337 self.variant(CDTI2LOC_A::LOC24)
1338 }
1339 #[doc = "Location 25"]
1340 #[inline(always)]
1341 pub fn loc25(self) -> &'a mut W {
1342 self.variant(CDTI2LOC_A::LOC25)
1343 }
1344 #[doc = "Location 26"]
1345 #[inline(always)]
1346 pub fn loc26(self) -> &'a mut W {
1347 self.variant(CDTI2LOC_A::LOC26)
1348 }
1349 #[doc = "Location 27"]
1350 #[inline(always)]
1351 pub fn loc27(self) -> &'a mut W {
1352 self.variant(CDTI2LOC_A::LOC27)
1353 }
1354 #[doc = "Location 28"]
1355 #[inline(always)]
1356 pub fn loc28(self) -> &'a mut W {
1357 self.variant(CDTI2LOC_A::LOC28)
1358 }
1359 #[doc = "Location 29"]
1360 #[inline(always)]
1361 pub fn loc29(self) -> &'a mut W {
1362 self.variant(CDTI2LOC_A::LOC29)
1363 }
1364 #[doc = "Location 30"]
1365 #[inline(always)]
1366 pub fn loc30(self) -> &'a mut W {
1367 self.variant(CDTI2LOC_A::LOC30)
1368 }
1369 #[doc = "Location 31"]
1370 #[inline(always)]
1371 pub fn loc31(self) -> &'a mut W {
1372 self.variant(CDTI2LOC_A::LOC31)
1373 }
1374 #[doc = r"Writes raw bits to the field"]
1375 #[inline(always)]
1376 pub unsafe fn bits(self, value: u8) -> &'a mut W {
1377 self.w.bits = (self.w.bits & !(0x3f << 16)) | (((value as u32) & 0x3f) << 16);
1378 self.w
1379 }
1380}
1381impl R {
1382 #[doc = "Bits 0:5 - I/O Location"]
1383 #[inline(always)]
1384 pub fn cdti0loc(&self) -> CDTI0LOC_R {
1385 CDTI0LOC_R::new((self.bits & 0x3f) as u8)
1386 }
1387 #[doc = "Bits 8:13 - I/O Location"]
1388 #[inline(always)]
1389 pub fn cdti1loc(&self) -> CDTI1LOC_R {
1390 CDTI1LOC_R::new(((self.bits >> 8) & 0x3f) as u8)
1391 }
1392 #[doc = "Bits 16:21 - I/O Location"]
1393 #[inline(always)]
1394 pub fn cdti2loc(&self) -> CDTI2LOC_R {
1395 CDTI2LOC_R::new(((self.bits >> 16) & 0x3f) as u8)
1396 }
1397}
1398impl W {
1399 #[doc = "Bits 0:5 - I/O Location"]
1400 #[inline(always)]
1401 pub fn cdti0loc(&mut self) -> CDTI0LOC_W {
1402 CDTI0LOC_W { w: self }
1403 }
1404 #[doc = "Bits 8:13 - I/O Location"]
1405 #[inline(always)]
1406 pub fn cdti1loc(&mut self) -> CDTI1LOC_W {
1407 CDTI1LOC_W { w: self }
1408 }
1409 #[doc = "Bits 16:21 - I/O Location"]
1410 #[inline(always)]
1411 pub fn cdti2loc(&mut self) -> CDTI2LOC_W {
1412 CDTI2LOC_W { w: self }
1413 }
1414}