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 RXLOC_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<RXLOC_A> for u8 {
83 #[inline(always)]
84 fn from(variant: RXLOC_A) -> Self {
85 variant as _
86 }
87}
88#[doc = "Reader of field `RXLOC`"]
89pub type RXLOC_R = crate::R<u8, RXLOC_A>;
90impl RXLOC_R {
91 #[doc = r"Get enumerated values variant"]
92 #[inline(always)]
93 pub fn variant(&self) -> crate::Variant<u8, RXLOC_A> {
94 use crate::Variant::*;
95 match self.bits {
96 0 => Val(RXLOC_A::LOC0),
97 1 => Val(RXLOC_A::LOC1),
98 2 => Val(RXLOC_A::LOC2),
99 3 => Val(RXLOC_A::LOC3),
100 4 => Val(RXLOC_A::LOC4),
101 5 => Val(RXLOC_A::LOC5),
102 6 => Val(RXLOC_A::LOC6),
103 7 => Val(RXLOC_A::LOC7),
104 8 => Val(RXLOC_A::LOC8),
105 9 => Val(RXLOC_A::LOC9),
106 10 => Val(RXLOC_A::LOC10),
107 11 => Val(RXLOC_A::LOC11),
108 12 => Val(RXLOC_A::LOC12),
109 13 => Val(RXLOC_A::LOC13),
110 14 => Val(RXLOC_A::LOC14),
111 15 => Val(RXLOC_A::LOC15),
112 16 => Val(RXLOC_A::LOC16),
113 17 => Val(RXLOC_A::LOC17),
114 18 => Val(RXLOC_A::LOC18),
115 19 => Val(RXLOC_A::LOC19),
116 20 => Val(RXLOC_A::LOC20),
117 21 => Val(RXLOC_A::LOC21),
118 22 => Val(RXLOC_A::LOC22),
119 23 => Val(RXLOC_A::LOC23),
120 24 => Val(RXLOC_A::LOC24),
121 25 => Val(RXLOC_A::LOC25),
122 26 => Val(RXLOC_A::LOC26),
123 27 => Val(RXLOC_A::LOC27),
124 28 => Val(RXLOC_A::LOC28),
125 29 => Val(RXLOC_A::LOC29),
126 30 => Val(RXLOC_A::LOC30),
127 31 => Val(RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_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 == RXLOC_A::LOC31
290 }
291}
292#[doc = "Write proxy for field `RXLOC`"]
293pub struct RXLOC_W<'a> {
294 w: &'a mut W,
295}
296impl<'a> RXLOC_W<'a> {
297 #[doc = r"Writes `variant` to the field"]
298 #[inline(always)]
299 pub fn variant(self, variant: RXLOC_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(RXLOC_A::LOC0)
306 }
307 #[doc = "Location 1"]
308 #[inline(always)]
309 pub fn loc1(self) -> &'a mut W {
310 self.variant(RXLOC_A::LOC1)
311 }
312 #[doc = "Location 2"]
313 #[inline(always)]
314 pub fn loc2(self) -> &'a mut W {
315 self.variant(RXLOC_A::LOC2)
316 }
317 #[doc = "Location 3"]
318 #[inline(always)]
319 pub fn loc3(self) -> &'a mut W {
320 self.variant(RXLOC_A::LOC3)
321 }
322 #[doc = "Location 4"]
323 #[inline(always)]
324 pub fn loc4(self) -> &'a mut W {
325 self.variant(RXLOC_A::LOC4)
326 }
327 #[doc = "Location 5"]
328 #[inline(always)]
329 pub fn loc5(self) -> &'a mut W {
330 self.variant(RXLOC_A::LOC5)
331 }
332 #[doc = "Location 6"]
333 #[inline(always)]
334 pub fn loc6(self) -> &'a mut W {
335 self.variant(RXLOC_A::LOC6)
336 }
337 #[doc = "Location 7"]
338 #[inline(always)]
339 pub fn loc7(self) -> &'a mut W {
340 self.variant(RXLOC_A::LOC7)
341 }
342 #[doc = "Location 8"]
343 #[inline(always)]
344 pub fn loc8(self) -> &'a mut W {
345 self.variant(RXLOC_A::LOC8)
346 }
347 #[doc = "Location 9"]
348 #[inline(always)]
349 pub fn loc9(self) -> &'a mut W {
350 self.variant(RXLOC_A::LOC9)
351 }
352 #[doc = "Location 10"]
353 #[inline(always)]
354 pub fn loc10(self) -> &'a mut W {
355 self.variant(RXLOC_A::LOC10)
356 }
357 #[doc = "Location 11"]
358 #[inline(always)]
359 pub fn loc11(self) -> &'a mut W {
360 self.variant(RXLOC_A::LOC11)
361 }
362 #[doc = "Location 12"]
363 #[inline(always)]
364 pub fn loc12(self) -> &'a mut W {
365 self.variant(RXLOC_A::LOC12)
366 }
367 #[doc = "Location 13"]
368 #[inline(always)]
369 pub fn loc13(self) -> &'a mut W {
370 self.variant(RXLOC_A::LOC13)
371 }
372 #[doc = "Location 14"]
373 #[inline(always)]
374 pub fn loc14(self) -> &'a mut W {
375 self.variant(RXLOC_A::LOC14)
376 }
377 #[doc = "Location 15"]
378 #[inline(always)]
379 pub fn loc15(self) -> &'a mut W {
380 self.variant(RXLOC_A::LOC15)
381 }
382 #[doc = "Location 16"]
383 #[inline(always)]
384 pub fn loc16(self) -> &'a mut W {
385 self.variant(RXLOC_A::LOC16)
386 }
387 #[doc = "Location 17"]
388 #[inline(always)]
389 pub fn loc17(self) -> &'a mut W {
390 self.variant(RXLOC_A::LOC17)
391 }
392 #[doc = "Location 18"]
393 #[inline(always)]
394 pub fn loc18(self) -> &'a mut W {
395 self.variant(RXLOC_A::LOC18)
396 }
397 #[doc = "Location 19"]
398 #[inline(always)]
399 pub fn loc19(self) -> &'a mut W {
400 self.variant(RXLOC_A::LOC19)
401 }
402 #[doc = "Location 20"]
403 #[inline(always)]
404 pub fn loc20(self) -> &'a mut W {
405 self.variant(RXLOC_A::LOC20)
406 }
407 #[doc = "Location 21"]
408 #[inline(always)]
409 pub fn loc21(self) -> &'a mut W {
410 self.variant(RXLOC_A::LOC21)
411 }
412 #[doc = "Location 22"]
413 #[inline(always)]
414 pub fn loc22(self) -> &'a mut W {
415 self.variant(RXLOC_A::LOC22)
416 }
417 #[doc = "Location 23"]
418 #[inline(always)]
419 pub fn loc23(self) -> &'a mut W {
420 self.variant(RXLOC_A::LOC23)
421 }
422 #[doc = "Location 24"]
423 #[inline(always)]
424 pub fn loc24(self) -> &'a mut W {
425 self.variant(RXLOC_A::LOC24)
426 }
427 #[doc = "Location 25"]
428 #[inline(always)]
429 pub fn loc25(self) -> &'a mut W {
430 self.variant(RXLOC_A::LOC25)
431 }
432 #[doc = "Location 26"]
433 #[inline(always)]
434 pub fn loc26(self) -> &'a mut W {
435 self.variant(RXLOC_A::LOC26)
436 }
437 #[doc = "Location 27"]
438 #[inline(always)]
439 pub fn loc27(self) -> &'a mut W {
440 self.variant(RXLOC_A::LOC27)
441 }
442 #[doc = "Location 28"]
443 #[inline(always)]
444 pub fn loc28(self) -> &'a mut W {
445 self.variant(RXLOC_A::LOC28)
446 }
447 #[doc = "Location 29"]
448 #[inline(always)]
449 pub fn loc29(self) -> &'a mut W {
450 self.variant(RXLOC_A::LOC29)
451 }
452 #[doc = "Location 30"]
453 #[inline(always)]
454 pub fn loc30(self) -> &'a mut W {
455 self.variant(RXLOC_A::LOC30)
456 }
457 #[doc = "Location 31"]
458 #[inline(always)]
459 pub fn loc31(self) -> &'a mut W {
460 self.variant(RXLOC_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 TXLOC_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<TXLOC_A> for u8 {
539 #[inline(always)]
540 fn from(variant: TXLOC_A) -> Self {
541 variant as _
542 }
543}
544#[doc = "Reader of field `TXLOC`"]
545pub type TXLOC_R = crate::R<u8, TXLOC_A>;
546impl TXLOC_R {
547 #[doc = r"Get enumerated values variant"]
548 #[inline(always)]
549 pub fn variant(&self) -> crate::Variant<u8, TXLOC_A> {
550 use crate::Variant::*;
551 match self.bits {
552 0 => Val(TXLOC_A::LOC0),
553 1 => Val(TXLOC_A::LOC1),
554 2 => Val(TXLOC_A::LOC2),
555 3 => Val(TXLOC_A::LOC3),
556 4 => Val(TXLOC_A::LOC4),
557 5 => Val(TXLOC_A::LOC5),
558 6 => Val(TXLOC_A::LOC6),
559 7 => Val(TXLOC_A::LOC7),
560 8 => Val(TXLOC_A::LOC8),
561 9 => Val(TXLOC_A::LOC9),
562 10 => Val(TXLOC_A::LOC10),
563 11 => Val(TXLOC_A::LOC11),
564 12 => Val(TXLOC_A::LOC12),
565 13 => Val(TXLOC_A::LOC13),
566 14 => Val(TXLOC_A::LOC14),
567 15 => Val(TXLOC_A::LOC15),
568 16 => Val(TXLOC_A::LOC16),
569 17 => Val(TXLOC_A::LOC17),
570 18 => Val(TXLOC_A::LOC18),
571 19 => Val(TXLOC_A::LOC19),
572 20 => Val(TXLOC_A::LOC20),
573 21 => Val(TXLOC_A::LOC21),
574 22 => Val(TXLOC_A::LOC22),
575 23 => Val(TXLOC_A::LOC23),
576 24 => Val(TXLOC_A::LOC24),
577 25 => Val(TXLOC_A::LOC25),
578 26 => Val(TXLOC_A::LOC26),
579 27 => Val(TXLOC_A::LOC27),
580 28 => Val(TXLOC_A::LOC28),
581 29 => Val(TXLOC_A::LOC29),
582 30 => Val(TXLOC_A::LOC30),
583 31 => Val(TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_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 == TXLOC_A::LOC31
746 }
747}
748#[doc = "Write proxy for field `TXLOC`"]
749pub struct TXLOC_W<'a> {
750 w: &'a mut W,
751}
752impl<'a> TXLOC_W<'a> {
753 #[doc = r"Writes `variant` to the field"]
754 #[inline(always)]
755 pub fn variant(self, variant: TXLOC_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(TXLOC_A::LOC0)
762 }
763 #[doc = "Location 1"]
764 #[inline(always)]
765 pub fn loc1(self) -> &'a mut W {
766 self.variant(TXLOC_A::LOC1)
767 }
768 #[doc = "Location 2"]
769 #[inline(always)]
770 pub fn loc2(self) -> &'a mut W {
771 self.variant(TXLOC_A::LOC2)
772 }
773 #[doc = "Location 3"]
774 #[inline(always)]
775 pub fn loc3(self) -> &'a mut W {
776 self.variant(TXLOC_A::LOC3)
777 }
778 #[doc = "Location 4"]
779 #[inline(always)]
780 pub fn loc4(self) -> &'a mut W {
781 self.variant(TXLOC_A::LOC4)
782 }
783 #[doc = "Location 5"]
784 #[inline(always)]
785 pub fn loc5(self) -> &'a mut W {
786 self.variant(TXLOC_A::LOC5)
787 }
788 #[doc = "Location 6"]
789 #[inline(always)]
790 pub fn loc6(self) -> &'a mut W {
791 self.variant(TXLOC_A::LOC6)
792 }
793 #[doc = "Location 7"]
794 #[inline(always)]
795 pub fn loc7(self) -> &'a mut W {
796 self.variant(TXLOC_A::LOC7)
797 }
798 #[doc = "Location 8"]
799 #[inline(always)]
800 pub fn loc8(self) -> &'a mut W {
801 self.variant(TXLOC_A::LOC8)
802 }
803 #[doc = "Location 9"]
804 #[inline(always)]
805 pub fn loc9(self) -> &'a mut W {
806 self.variant(TXLOC_A::LOC9)
807 }
808 #[doc = "Location 10"]
809 #[inline(always)]
810 pub fn loc10(self) -> &'a mut W {
811 self.variant(TXLOC_A::LOC10)
812 }
813 #[doc = "Location 11"]
814 #[inline(always)]
815 pub fn loc11(self) -> &'a mut W {
816 self.variant(TXLOC_A::LOC11)
817 }
818 #[doc = "Location 12"]
819 #[inline(always)]
820 pub fn loc12(self) -> &'a mut W {
821 self.variant(TXLOC_A::LOC12)
822 }
823 #[doc = "Location 13"]
824 #[inline(always)]
825 pub fn loc13(self) -> &'a mut W {
826 self.variant(TXLOC_A::LOC13)
827 }
828 #[doc = "Location 14"]
829 #[inline(always)]
830 pub fn loc14(self) -> &'a mut W {
831 self.variant(TXLOC_A::LOC14)
832 }
833 #[doc = "Location 15"]
834 #[inline(always)]
835 pub fn loc15(self) -> &'a mut W {
836 self.variant(TXLOC_A::LOC15)
837 }
838 #[doc = "Location 16"]
839 #[inline(always)]
840 pub fn loc16(self) -> &'a mut W {
841 self.variant(TXLOC_A::LOC16)
842 }
843 #[doc = "Location 17"]
844 #[inline(always)]
845 pub fn loc17(self) -> &'a mut W {
846 self.variant(TXLOC_A::LOC17)
847 }
848 #[doc = "Location 18"]
849 #[inline(always)]
850 pub fn loc18(self) -> &'a mut W {
851 self.variant(TXLOC_A::LOC18)
852 }
853 #[doc = "Location 19"]
854 #[inline(always)]
855 pub fn loc19(self) -> &'a mut W {
856 self.variant(TXLOC_A::LOC19)
857 }
858 #[doc = "Location 20"]
859 #[inline(always)]
860 pub fn loc20(self) -> &'a mut W {
861 self.variant(TXLOC_A::LOC20)
862 }
863 #[doc = "Location 21"]
864 #[inline(always)]
865 pub fn loc21(self) -> &'a mut W {
866 self.variant(TXLOC_A::LOC21)
867 }
868 #[doc = "Location 22"]
869 #[inline(always)]
870 pub fn loc22(self) -> &'a mut W {
871 self.variant(TXLOC_A::LOC22)
872 }
873 #[doc = "Location 23"]
874 #[inline(always)]
875 pub fn loc23(self) -> &'a mut W {
876 self.variant(TXLOC_A::LOC23)
877 }
878 #[doc = "Location 24"]
879 #[inline(always)]
880 pub fn loc24(self) -> &'a mut W {
881 self.variant(TXLOC_A::LOC24)
882 }
883 #[doc = "Location 25"]
884 #[inline(always)]
885 pub fn loc25(self) -> &'a mut W {
886 self.variant(TXLOC_A::LOC25)
887 }
888 #[doc = "Location 26"]
889 #[inline(always)]
890 pub fn loc26(self) -> &'a mut W {
891 self.variant(TXLOC_A::LOC26)
892 }
893 #[doc = "Location 27"]
894 #[inline(always)]
895 pub fn loc27(self) -> &'a mut W {
896 self.variant(TXLOC_A::LOC27)
897 }
898 #[doc = "Location 28"]
899 #[inline(always)]
900 pub fn loc28(self) -> &'a mut W {
901 self.variant(TXLOC_A::LOC28)
902 }
903 #[doc = "Location 29"]
904 #[inline(always)]
905 pub fn loc29(self) -> &'a mut W {
906 self.variant(TXLOC_A::LOC29)
907 }
908 #[doc = "Location 30"]
909 #[inline(always)]
910 pub fn loc30(self) -> &'a mut W {
911 self.variant(TXLOC_A::LOC30)
912 }
913 #[doc = "Location 31"]
914 #[inline(always)]
915 pub fn loc31(self) -> &'a mut W {
916 self.variant(TXLOC_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 CSLOC_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<CSLOC_A> for u8 {
995 #[inline(always)]
996 fn from(variant: CSLOC_A) -> Self {
997 variant as _
998 }
999}
1000#[doc = "Reader of field `CSLOC`"]
1001pub type CSLOC_R = crate::R<u8, CSLOC_A>;
1002impl CSLOC_R {
1003 #[doc = r"Get enumerated values variant"]
1004 #[inline(always)]
1005 pub fn variant(&self) -> crate::Variant<u8, CSLOC_A> {
1006 use crate::Variant::*;
1007 match self.bits {
1008 0 => Val(CSLOC_A::LOC0),
1009 1 => Val(CSLOC_A::LOC1),
1010 2 => Val(CSLOC_A::LOC2),
1011 3 => Val(CSLOC_A::LOC3),
1012 4 => Val(CSLOC_A::LOC4),
1013 5 => Val(CSLOC_A::LOC5),
1014 6 => Val(CSLOC_A::LOC6),
1015 7 => Val(CSLOC_A::LOC7),
1016 8 => Val(CSLOC_A::LOC8),
1017 9 => Val(CSLOC_A::LOC9),
1018 10 => Val(CSLOC_A::LOC10),
1019 11 => Val(CSLOC_A::LOC11),
1020 12 => Val(CSLOC_A::LOC12),
1021 13 => Val(CSLOC_A::LOC13),
1022 14 => Val(CSLOC_A::LOC14),
1023 15 => Val(CSLOC_A::LOC15),
1024 16 => Val(CSLOC_A::LOC16),
1025 17 => Val(CSLOC_A::LOC17),
1026 18 => Val(CSLOC_A::LOC18),
1027 19 => Val(CSLOC_A::LOC19),
1028 20 => Val(CSLOC_A::LOC20),
1029 21 => Val(CSLOC_A::LOC21),
1030 22 => Val(CSLOC_A::LOC22),
1031 23 => Val(CSLOC_A::LOC23),
1032 24 => Val(CSLOC_A::LOC24),
1033 25 => Val(CSLOC_A::LOC25),
1034 26 => Val(CSLOC_A::LOC26),
1035 27 => Val(CSLOC_A::LOC27),
1036 28 => Val(CSLOC_A::LOC28),
1037 29 => Val(CSLOC_A::LOC29),
1038 30 => Val(CSLOC_A::LOC30),
1039 31 => Val(CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_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 == CSLOC_A::LOC31
1202 }
1203}
1204#[doc = "Write proxy for field `CSLOC`"]
1205pub struct CSLOC_W<'a> {
1206 w: &'a mut W,
1207}
1208impl<'a> CSLOC_W<'a> {
1209 #[doc = r"Writes `variant` to the field"]
1210 #[inline(always)]
1211 pub fn variant(self, variant: CSLOC_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(CSLOC_A::LOC0)
1218 }
1219 #[doc = "Location 1"]
1220 #[inline(always)]
1221 pub fn loc1(self) -> &'a mut W {
1222 self.variant(CSLOC_A::LOC1)
1223 }
1224 #[doc = "Location 2"]
1225 #[inline(always)]
1226 pub fn loc2(self) -> &'a mut W {
1227 self.variant(CSLOC_A::LOC2)
1228 }
1229 #[doc = "Location 3"]
1230 #[inline(always)]
1231 pub fn loc3(self) -> &'a mut W {
1232 self.variant(CSLOC_A::LOC3)
1233 }
1234 #[doc = "Location 4"]
1235 #[inline(always)]
1236 pub fn loc4(self) -> &'a mut W {
1237 self.variant(CSLOC_A::LOC4)
1238 }
1239 #[doc = "Location 5"]
1240 #[inline(always)]
1241 pub fn loc5(self) -> &'a mut W {
1242 self.variant(CSLOC_A::LOC5)
1243 }
1244 #[doc = "Location 6"]
1245 #[inline(always)]
1246 pub fn loc6(self) -> &'a mut W {
1247 self.variant(CSLOC_A::LOC6)
1248 }
1249 #[doc = "Location 7"]
1250 #[inline(always)]
1251 pub fn loc7(self) -> &'a mut W {
1252 self.variant(CSLOC_A::LOC7)
1253 }
1254 #[doc = "Location 8"]
1255 #[inline(always)]
1256 pub fn loc8(self) -> &'a mut W {
1257 self.variant(CSLOC_A::LOC8)
1258 }
1259 #[doc = "Location 9"]
1260 #[inline(always)]
1261 pub fn loc9(self) -> &'a mut W {
1262 self.variant(CSLOC_A::LOC9)
1263 }
1264 #[doc = "Location 10"]
1265 #[inline(always)]
1266 pub fn loc10(self) -> &'a mut W {
1267 self.variant(CSLOC_A::LOC10)
1268 }
1269 #[doc = "Location 11"]
1270 #[inline(always)]
1271 pub fn loc11(self) -> &'a mut W {
1272 self.variant(CSLOC_A::LOC11)
1273 }
1274 #[doc = "Location 12"]
1275 #[inline(always)]
1276 pub fn loc12(self) -> &'a mut W {
1277 self.variant(CSLOC_A::LOC12)
1278 }
1279 #[doc = "Location 13"]
1280 #[inline(always)]
1281 pub fn loc13(self) -> &'a mut W {
1282 self.variant(CSLOC_A::LOC13)
1283 }
1284 #[doc = "Location 14"]
1285 #[inline(always)]
1286 pub fn loc14(self) -> &'a mut W {
1287 self.variant(CSLOC_A::LOC14)
1288 }
1289 #[doc = "Location 15"]
1290 #[inline(always)]
1291 pub fn loc15(self) -> &'a mut W {
1292 self.variant(CSLOC_A::LOC15)
1293 }
1294 #[doc = "Location 16"]
1295 #[inline(always)]
1296 pub fn loc16(self) -> &'a mut W {
1297 self.variant(CSLOC_A::LOC16)
1298 }
1299 #[doc = "Location 17"]
1300 #[inline(always)]
1301 pub fn loc17(self) -> &'a mut W {
1302 self.variant(CSLOC_A::LOC17)
1303 }
1304 #[doc = "Location 18"]
1305 #[inline(always)]
1306 pub fn loc18(self) -> &'a mut W {
1307 self.variant(CSLOC_A::LOC18)
1308 }
1309 #[doc = "Location 19"]
1310 #[inline(always)]
1311 pub fn loc19(self) -> &'a mut W {
1312 self.variant(CSLOC_A::LOC19)
1313 }
1314 #[doc = "Location 20"]
1315 #[inline(always)]
1316 pub fn loc20(self) -> &'a mut W {
1317 self.variant(CSLOC_A::LOC20)
1318 }
1319 #[doc = "Location 21"]
1320 #[inline(always)]
1321 pub fn loc21(self) -> &'a mut W {
1322 self.variant(CSLOC_A::LOC21)
1323 }
1324 #[doc = "Location 22"]
1325 #[inline(always)]
1326 pub fn loc22(self) -> &'a mut W {
1327 self.variant(CSLOC_A::LOC22)
1328 }
1329 #[doc = "Location 23"]
1330 #[inline(always)]
1331 pub fn loc23(self) -> &'a mut W {
1332 self.variant(CSLOC_A::LOC23)
1333 }
1334 #[doc = "Location 24"]
1335 #[inline(always)]
1336 pub fn loc24(self) -> &'a mut W {
1337 self.variant(CSLOC_A::LOC24)
1338 }
1339 #[doc = "Location 25"]
1340 #[inline(always)]
1341 pub fn loc25(self) -> &'a mut W {
1342 self.variant(CSLOC_A::LOC25)
1343 }
1344 #[doc = "Location 26"]
1345 #[inline(always)]
1346 pub fn loc26(self) -> &'a mut W {
1347 self.variant(CSLOC_A::LOC26)
1348 }
1349 #[doc = "Location 27"]
1350 #[inline(always)]
1351 pub fn loc27(self) -> &'a mut W {
1352 self.variant(CSLOC_A::LOC27)
1353 }
1354 #[doc = "Location 28"]
1355 #[inline(always)]
1356 pub fn loc28(self) -> &'a mut W {
1357 self.variant(CSLOC_A::LOC28)
1358 }
1359 #[doc = "Location 29"]
1360 #[inline(always)]
1361 pub fn loc29(self) -> &'a mut W {
1362 self.variant(CSLOC_A::LOC29)
1363 }
1364 #[doc = "Location 30"]
1365 #[inline(always)]
1366 pub fn loc30(self) -> &'a mut W {
1367 self.variant(CSLOC_A::LOC30)
1368 }
1369 #[doc = "Location 31"]
1370 #[inline(always)]
1371 pub fn loc31(self) -> &'a mut W {
1372 self.variant(CSLOC_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}
1381#[doc = "I/O Location\n\nValue on reset: 0"]
1382#[derive(Clone, Copy, Debug, PartialEq)]
1383#[repr(u8)]
1384pub enum CLKLOC_A {
1385 #[doc = "0: Location 0"]
1386 LOC0 = 0,
1387 #[doc = "1: Location 1"]
1388 LOC1 = 1,
1389 #[doc = "2: Location 2"]
1390 LOC2 = 2,
1391 #[doc = "3: Location 3"]
1392 LOC3 = 3,
1393 #[doc = "4: Location 4"]
1394 LOC4 = 4,
1395 #[doc = "5: Location 5"]
1396 LOC5 = 5,
1397 #[doc = "6: Location 6"]
1398 LOC6 = 6,
1399 #[doc = "7: Location 7"]
1400 LOC7 = 7,
1401 #[doc = "8: Location 8"]
1402 LOC8 = 8,
1403 #[doc = "9: Location 9"]
1404 LOC9 = 9,
1405 #[doc = "10: Location 10"]
1406 LOC10 = 10,
1407 #[doc = "11: Location 11"]
1408 LOC11 = 11,
1409 #[doc = "12: Location 12"]
1410 LOC12 = 12,
1411 #[doc = "13: Location 13"]
1412 LOC13 = 13,
1413 #[doc = "14: Location 14"]
1414 LOC14 = 14,
1415 #[doc = "15: Location 15"]
1416 LOC15 = 15,
1417 #[doc = "16: Location 16"]
1418 LOC16 = 16,
1419 #[doc = "17: Location 17"]
1420 LOC17 = 17,
1421 #[doc = "18: Location 18"]
1422 LOC18 = 18,
1423 #[doc = "19: Location 19"]
1424 LOC19 = 19,
1425 #[doc = "20: Location 20"]
1426 LOC20 = 20,
1427 #[doc = "21: Location 21"]
1428 LOC21 = 21,
1429 #[doc = "22: Location 22"]
1430 LOC22 = 22,
1431 #[doc = "23: Location 23"]
1432 LOC23 = 23,
1433 #[doc = "24: Location 24"]
1434 LOC24 = 24,
1435 #[doc = "25: Location 25"]
1436 LOC25 = 25,
1437 #[doc = "26: Location 26"]
1438 LOC26 = 26,
1439 #[doc = "27: Location 27"]
1440 LOC27 = 27,
1441 #[doc = "28: Location 28"]
1442 LOC28 = 28,
1443 #[doc = "29: Location 29"]
1444 LOC29 = 29,
1445 #[doc = "30: Location 30"]
1446 LOC30 = 30,
1447 #[doc = "31: Location 31"]
1448 LOC31 = 31,
1449}
1450impl From<CLKLOC_A> for u8 {
1451 #[inline(always)]
1452 fn from(variant: CLKLOC_A) -> Self {
1453 variant as _
1454 }
1455}
1456#[doc = "Reader of field `CLKLOC`"]
1457pub type CLKLOC_R = crate::R<u8, CLKLOC_A>;
1458impl CLKLOC_R {
1459 #[doc = r"Get enumerated values variant"]
1460 #[inline(always)]
1461 pub fn variant(&self) -> crate::Variant<u8, CLKLOC_A> {
1462 use crate::Variant::*;
1463 match self.bits {
1464 0 => Val(CLKLOC_A::LOC0),
1465 1 => Val(CLKLOC_A::LOC1),
1466 2 => Val(CLKLOC_A::LOC2),
1467 3 => Val(CLKLOC_A::LOC3),
1468 4 => Val(CLKLOC_A::LOC4),
1469 5 => Val(CLKLOC_A::LOC5),
1470 6 => Val(CLKLOC_A::LOC6),
1471 7 => Val(CLKLOC_A::LOC7),
1472 8 => Val(CLKLOC_A::LOC8),
1473 9 => Val(CLKLOC_A::LOC9),
1474 10 => Val(CLKLOC_A::LOC10),
1475 11 => Val(CLKLOC_A::LOC11),
1476 12 => Val(CLKLOC_A::LOC12),
1477 13 => Val(CLKLOC_A::LOC13),
1478 14 => Val(CLKLOC_A::LOC14),
1479 15 => Val(CLKLOC_A::LOC15),
1480 16 => Val(CLKLOC_A::LOC16),
1481 17 => Val(CLKLOC_A::LOC17),
1482 18 => Val(CLKLOC_A::LOC18),
1483 19 => Val(CLKLOC_A::LOC19),
1484 20 => Val(CLKLOC_A::LOC20),
1485 21 => Val(CLKLOC_A::LOC21),
1486 22 => Val(CLKLOC_A::LOC22),
1487 23 => Val(CLKLOC_A::LOC23),
1488 24 => Val(CLKLOC_A::LOC24),
1489 25 => Val(CLKLOC_A::LOC25),
1490 26 => Val(CLKLOC_A::LOC26),
1491 27 => Val(CLKLOC_A::LOC27),
1492 28 => Val(CLKLOC_A::LOC28),
1493 29 => Val(CLKLOC_A::LOC29),
1494 30 => Val(CLKLOC_A::LOC30),
1495 31 => Val(CLKLOC_A::LOC31),
1496 i => Res(i),
1497 }
1498 }
1499 #[doc = "Checks if the value of the field is `LOC0`"]
1500 #[inline(always)]
1501 pub fn is_loc0(&self) -> bool {
1502 *self == CLKLOC_A::LOC0
1503 }
1504 #[doc = "Checks if the value of the field is `LOC1`"]
1505 #[inline(always)]
1506 pub fn is_loc1(&self) -> bool {
1507 *self == CLKLOC_A::LOC1
1508 }
1509 #[doc = "Checks if the value of the field is `LOC2`"]
1510 #[inline(always)]
1511 pub fn is_loc2(&self) -> bool {
1512 *self == CLKLOC_A::LOC2
1513 }
1514 #[doc = "Checks if the value of the field is `LOC3`"]
1515 #[inline(always)]
1516 pub fn is_loc3(&self) -> bool {
1517 *self == CLKLOC_A::LOC3
1518 }
1519 #[doc = "Checks if the value of the field is `LOC4`"]
1520 #[inline(always)]
1521 pub fn is_loc4(&self) -> bool {
1522 *self == CLKLOC_A::LOC4
1523 }
1524 #[doc = "Checks if the value of the field is `LOC5`"]
1525 #[inline(always)]
1526 pub fn is_loc5(&self) -> bool {
1527 *self == CLKLOC_A::LOC5
1528 }
1529 #[doc = "Checks if the value of the field is `LOC6`"]
1530 #[inline(always)]
1531 pub fn is_loc6(&self) -> bool {
1532 *self == CLKLOC_A::LOC6
1533 }
1534 #[doc = "Checks if the value of the field is `LOC7`"]
1535 #[inline(always)]
1536 pub fn is_loc7(&self) -> bool {
1537 *self == CLKLOC_A::LOC7
1538 }
1539 #[doc = "Checks if the value of the field is `LOC8`"]
1540 #[inline(always)]
1541 pub fn is_loc8(&self) -> bool {
1542 *self == CLKLOC_A::LOC8
1543 }
1544 #[doc = "Checks if the value of the field is `LOC9`"]
1545 #[inline(always)]
1546 pub fn is_loc9(&self) -> bool {
1547 *self == CLKLOC_A::LOC9
1548 }
1549 #[doc = "Checks if the value of the field is `LOC10`"]
1550 #[inline(always)]
1551 pub fn is_loc10(&self) -> bool {
1552 *self == CLKLOC_A::LOC10
1553 }
1554 #[doc = "Checks if the value of the field is `LOC11`"]
1555 #[inline(always)]
1556 pub fn is_loc11(&self) -> bool {
1557 *self == CLKLOC_A::LOC11
1558 }
1559 #[doc = "Checks if the value of the field is `LOC12`"]
1560 #[inline(always)]
1561 pub fn is_loc12(&self) -> bool {
1562 *self == CLKLOC_A::LOC12
1563 }
1564 #[doc = "Checks if the value of the field is `LOC13`"]
1565 #[inline(always)]
1566 pub fn is_loc13(&self) -> bool {
1567 *self == CLKLOC_A::LOC13
1568 }
1569 #[doc = "Checks if the value of the field is `LOC14`"]
1570 #[inline(always)]
1571 pub fn is_loc14(&self) -> bool {
1572 *self == CLKLOC_A::LOC14
1573 }
1574 #[doc = "Checks if the value of the field is `LOC15`"]
1575 #[inline(always)]
1576 pub fn is_loc15(&self) -> bool {
1577 *self == CLKLOC_A::LOC15
1578 }
1579 #[doc = "Checks if the value of the field is `LOC16`"]
1580 #[inline(always)]
1581 pub fn is_loc16(&self) -> bool {
1582 *self == CLKLOC_A::LOC16
1583 }
1584 #[doc = "Checks if the value of the field is `LOC17`"]
1585 #[inline(always)]
1586 pub fn is_loc17(&self) -> bool {
1587 *self == CLKLOC_A::LOC17
1588 }
1589 #[doc = "Checks if the value of the field is `LOC18`"]
1590 #[inline(always)]
1591 pub fn is_loc18(&self) -> bool {
1592 *self == CLKLOC_A::LOC18
1593 }
1594 #[doc = "Checks if the value of the field is `LOC19`"]
1595 #[inline(always)]
1596 pub fn is_loc19(&self) -> bool {
1597 *self == CLKLOC_A::LOC19
1598 }
1599 #[doc = "Checks if the value of the field is `LOC20`"]
1600 #[inline(always)]
1601 pub fn is_loc20(&self) -> bool {
1602 *self == CLKLOC_A::LOC20
1603 }
1604 #[doc = "Checks if the value of the field is `LOC21`"]
1605 #[inline(always)]
1606 pub fn is_loc21(&self) -> bool {
1607 *self == CLKLOC_A::LOC21
1608 }
1609 #[doc = "Checks if the value of the field is `LOC22`"]
1610 #[inline(always)]
1611 pub fn is_loc22(&self) -> bool {
1612 *self == CLKLOC_A::LOC22
1613 }
1614 #[doc = "Checks if the value of the field is `LOC23`"]
1615 #[inline(always)]
1616 pub fn is_loc23(&self) -> bool {
1617 *self == CLKLOC_A::LOC23
1618 }
1619 #[doc = "Checks if the value of the field is `LOC24`"]
1620 #[inline(always)]
1621 pub fn is_loc24(&self) -> bool {
1622 *self == CLKLOC_A::LOC24
1623 }
1624 #[doc = "Checks if the value of the field is `LOC25`"]
1625 #[inline(always)]
1626 pub fn is_loc25(&self) -> bool {
1627 *self == CLKLOC_A::LOC25
1628 }
1629 #[doc = "Checks if the value of the field is `LOC26`"]
1630 #[inline(always)]
1631 pub fn is_loc26(&self) -> bool {
1632 *self == CLKLOC_A::LOC26
1633 }
1634 #[doc = "Checks if the value of the field is `LOC27`"]
1635 #[inline(always)]
1636 pub fn is_loc27(&self) -> bool {
1637 *self == CLKLOC_A::LOC27
1638 }
1639 #[doc = "Checks if the value of the field is `LOC28`"]
1640 #[inline(always)]
1641 pub fn is_loc28(&self) -> bool {
1642 *self == CLKLOC_A::LOC28
1643 }
1644 #[doc = "Checks if the value of the field is `LOC29`"]
1645 #[inline(always)]
1646 pub fn is_loc29(&self) -> bool {
1647 *self == CLKLOC_A::LOC29
1648 }
1649 #[doc = "Checks if the value of the field is `LOC30`"]
1650 #[inline(always)]
1651 pub fn is_loc30(&self) -> bool {
1652 *self == CLKLOC_A::LOC30
1653 }
1654 #[doc = "Checks if the value of the field is `LOC31`"]
1655 #[inline(always)]
1656 pub fn is_loc31(&self) -> bool {
1657 *self == CLKLOC_A::LOC31
1658 }
1659}
1660#[doc = "Write proxy for field `CLKLOC`"]
1661pub struct CLKLOC_W<'a> {
1662 w: &'a mut W,
1663}
1664impl<'a> CLKLOC_W<'a> {
1665 #[doc = r"Writes `variant` to the field"]
1666 #[inline(always)]
1667 pub fn variant(self, variant: CLKLOC_A) -> &'a mut W {
1668 unsafe { self.bits(variant.into()) }
1669 }
1670 #[doc = "Location 0"]
1671 #[inline(always)]
1672 pub fn loc0(self) -> &'a mut W {
1673 self.variant(CLKLOC_A::LOC0)
1674 }
1675 #[doc = "Location 1"]
1676 #[inline(always)]
1677 pub fn loc1(self) -> &'a mut W {
1678 self.variant(CLKLOC_A::LOC1)
1679 }
1680 #[doc = "Location 2"]
1681 #[inline(always)]
1682 pub fn loc2(self) -> &'a mut W {
1683 self.variant(CLKLOC_A::LOC2)
1684 }
1685 #[doc = "Location 3"]
1686 #[inline(always)]
1687 pub fn loc3(self) -> &'a mut W {
1688 self.variant(CLKLOC_A::LOC3)
1689 }
1690 #[doc = "Location 4"]
1691 #[inline(always)]
1692 pub fn loc4(self) -> &'a mut W {
1693 self.variant(CLKLOC_A::LOC4)
1694 }
1695 #[doc = "Location 5"]
1696 #[inline(always)]
1697 pub fn loc5(self) -> &'a mut W {
1698 self.variant(CLKLOC_A::LOC5)
1699 }
1700 #[doc = "Location 6"]
1701 #[inline(always)]
1702 pub fn loc6(self) -> &'a mut W {
1703 self.variant(CLKLOC_A::LOC6)
1704 }
1705 #[doc = "Location 7"]
1706 #[inline(always)]
1707 pub fn loc7(self) -> &'a mut W {
1708 self.variant(CLKLOC_A::LOC7)
1709 }
1710 #[doc = "Location 8"]
1711 #[inline(always)]
1712 pub fn loc8(self) -> &'a mut W {
1713 self.variant(CLKLOC_A::LOC8)
1714 }
1715 #[doc = "Location 9"]
1716 #[inline(always)]
1717 pub fn loc9(self) -> &'a mut W {
1718 self.variant(CLKLOC_A::LOC9)
1719 }
1720 #[doc = "Location 10"]
1721 #[inline(always)]
1722 pub fn loc10(self) -> &'a mut W {
1723 self.variant(CLKLOC_A::LOC10)
1724 }
1725 #[doc = "Location 11"]
1726 #[inline(always)]
1727 pub fn loc11(self) -> &'a mut W {
1728 self.variant(CLKLOC_A::LOC11)
1729 }
1730 #[doc = "Location 12"]
1731 #[inline(always)]
1732 pub fn loc12(self) -> &'a mut W {
1733 self.variant(CLKLOC_A::LOC12)
1734 }
1735 #[doc = "Location 13"]
1736 #[inline(always)]
1737 pub fn loc13(self) -> &'a mut W {
1738 self.variant(CLKLOC_A::LOC13)
1739 }
1740 #[doc = "Location 14"]
1741 #[inline(always)]
1742 pub fn loc14(self) -> &'a mut W {
1743 self.variant(CLKLOC_A::LOC14)
1744 }
1745 #[doc = "Location 15"]
1746 #[inline(always)]
1747 pub fn loc15(self) -> &'a mut W {
1748 self.variant(CLKLOC_A::LOC15)
1749 }
1750 #[doc = "Location 16"]
1751 #[inline(always)]
1752 pub fn loc16(self) -> &'a mut W {
1753 self.variant(CLKLOC_A::LOC16)
1754 }
1755 #[doc = "Location 17"]
1756 #[inline(always)]
1757 pub fn loc17(self) -> &'a mut W {
1758 self.variant(CLKLOC_A::LOC17)
1759 }
1760 #[doc = "Location 18"]
1761 #[inline(always)]
1762 pub fn loc18(self) -> &'a mut W {
1763 self.variant(CLKLOC_A::LOC18)
1764 }
1765 #[doc = "Location 19"]
1766 #[inline(always)]
1767 pub fn loc19(self) -> &'a mut W {
1768 self.variant(CLKLOC_A::LOC19)
1769 }
1770 #[doc = "Location 20"]
1771 #[inline(always)]
1772 pub fn loc20(self) -> &'a mut W {
1773 self.variant(CLKLOC_A::LOC20)
1774 }
1775 #[doc = "Location 21"]
1776 #[inline(always)]
1777 pub fn loc21(self) -> &'a mut W {
1778 self.variant(CLKLOC_A::LOC21)
1779 }
1780 #[doc = "Location 22"]
1781 #[inline(always)]
1782 pub fn loc22(self) -> &'a mut W {
1783 self.variant(CLKLOC_A::LOC22)
1784 }
1785 #[doc = "Location 23"]
1786 #[inline(always)]
1787 pub fn loc23(self) -> &'a mut W {
1788 self.variant(CLKLOC_A::LOC23)
1789 }
1790 #[doc = "Location 24"]
1791 #[inline(always)]
1792 pub fn loc24(self) -> &'a mut W {
1793 self.variant(CLKLOC_A::LOC24)
1794 }
1795 #[doc = "Location 25"]
1796 #[inline(always)]
1797 pub fn loc25(self) -> &'a mut W {
1798 self.variant(CLKLOC_A::LOC25)
1799 }
1800 #[doc = "Location 26"]
1801 #[inline(always)]
1802 pub fn loc26(self) -> &'a mut W {
1803 self.variant(CLKLOC_A::LOC26)
1804 }
1805 #[doc = "Location 27"]
1806 #[inline(always)]
1807 pub fn loc27(self) -> &'a mut W {
1808 self.variant(CLKLOC_A::LOC27)
1809 }
1810 #[doc = "Location 28"]
1811 #[inline(always)]
1812 pub fn loc28(self) -> &'a mut W {
1813 self.variant(CLKLOC_A::LOC28)
1814 }
1815 #[doc = "Location 29"]
1816 #[inline(always)]
1817 pub fn loc29(self) -> &'a mut W {
1818 self.variant(CLKLOC_A::LOC29)
1819 }
1820 #[doc = "Location 30"]
1821 #[inline(always)]
1822 pub fn loc30(self) -> &'a mut W {
1823 self.variant(CLKLOC_A::LOC30)
1824 }
1825 #[doc = "Location 31"]
1826 #[inline(always)]
1827 pub fn loc31(self) -> &'a mut W {
1828 self.variant(CLKLOC_A::LOC31)
1829 }
1830 #[doc = r"Writes raw bits to the field"]
1831 #[inline(always)]
1832 pub unsafe fn bits(self, value: u8) -> &'a mut W {
1833 self.w.bits = (self.w.bits & !(0x3f << 24)) | (((value as u32) & 0x3f) << 24);
1834 self.w
1835 }
1836}
1837impl R {
1838 #[doc = "Bits 0:5 - I/O Location"]
1839 #[inline(always)]
1840 pub fn rxloc(&self) -> RXLOC_R {
1841 RXLOC_R::new((self.bits & 0x3f) as u8)
1842 }
1843 #[doc = "Bits 8:13 - I/O Location"]
1844 #[inline(always)]
1845 pub fn txloc(&self) -> TXLOC_R {
1846 TXLOC_R::new(((self.bits >> 8) & 0x3f) as u8)
1847 }
1848 #[doc = "Bits 16:21 - I/O Location"]
1849 #[inline(always)]
1850 pub fn csloc(&self) -> CSLOC_R {
1851 CSLOC_R::new(((self.bits >> 16) & 0x3f) as u8)
1852 }
1853 #[doc = "Bits 24:29 - I/O Location"]
1854 #[inline(always)]
1855 pub fn clkloc(&self) -> CLKLOC_R {
1856 CLKLOC_R::new(((self.bits >> 24) & 0x3f) as u8)
1857 }
1858}
1859impl W {
1860 #[doc = "Bits 0:5 - I/O Location"]
1861 #[inline(always)]
1862 pub fn rxloc(&mut self) -> RXLOC_W {
1863 RXLOC_W { w: self }
1864 }
1865 #[doc = "Bits 8:13 - I/O Location"]
1866 #[inline(always)]
1867 pub fn txloc(&mut self) -> TXLOC_W {
1868 TXLOC_W { w: self }
1869 }
1870 #[doc = "Bits 16:21 - I/O Location"]
1871 #[inline(always)]
1872 pub fn csloc(&mut self) -> CSLOC_W {
1873 CSLOC_W { w: self }
1874 }
1875 #[doc = "Bits 24:29 - I/O Location"]
1876 #[inline(always)]
1877 pub fn clkloc(&mut self) -> CLKLOC_W {
1878 CLKLOC_W { w: self }
1879 }
1880}