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 SDALOC_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<SDALOC_A> for u8 {
83 #[inline(always)]
84 fn from(variant: SDALOC_A) -> Self {
85 variant as _
86 }
87}
88#[doc = "Reader of field `SDALOC`"]
89pub type SDALOC_R = crate::R<u8, SDALOC_A>;
90impl SDALOC_R {
91 #[doc = r"Get enumerated values variant"]
92 #[inline(always)]
93 pub fn variant(&self) -> crate::Variant<u8, SDALOC_A> {
94 use crate::Variant::*;
95 match self.bits {
96 0 => Val(SDALOC_A::LOC0),
97 1 => Val(SDALOC_A::LOC1),
98 2 => Val(SDALOC_A::LOC2),
99 3 => Val(SDALOC_A::LOC3),
100 4 => Val(SDALOC_A::LOC4),
101 5 => Val(SDALOC_A::LOC5),
102 6 => Val(SDALOC_A::LOC6),
103 7 => Val(SDALOC_A::LOC7),
104 8 => Val(SDALOC_A::LOC8),
105 9 => Val(SDALOC_A::LOC9),
106 10 => Val(SDALOC_A::LOC10),
107 11 => Val(SDALOC_A::LOC11),
108 12 => Val(SDALOC_A::LOC12),
109 13 => Val(SDALOC_A::LOC13),
110 14 => Val(SDALOC_A::LOC14),
111 15 => Val(SDALOC_A::LOC15),
112 16 => Val(SDALOC_A::LOC16),
113 17 => Val(SDALOC_A::LOC17),
114 18 => Val(SDALOC_A::LOC18),
115 19 => Val(SDALOC_A::LOC19),
116 20 => Val(SDALOC_A::LOC20),
117 21 => Val(SDALOC_A::LOC21),
118 22 => Val(SDALOC_A::LOC22),
119 23 => Val(SDALOC_A::LOC23),
120 24 => Val(SDALOC_A::LOC24),
121 25 => Val(SDALOC_A::LOC25),
122 26 => Val(SDALOC_A::LOC26),
123 27 => Val(SDALOC_A::LOC27),
124 28 => Val(SDALOC_A::LOC28),
125 29 => Val(SDALOC_A::LOC29),
126 30 => Val(SDALOC_A::LOC30),
127 31 => Val(SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_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 == SDALOC_A::LOC31
290 }
291}
292#[doc = "Write proxy for field `SDALOC`"]
293pub struct SDALOC_W<'a> {
294 w: &'a mut W,
295}
296impl<'a> SDALOC_W<'a> {
297 #[doc = r"Writes `variant` to the field"]
298 #[inline(always)]
299 pub fn variant(self, variant: SDALOC_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(SDALOC_A::LOC0)
306 }
307 #[doc = "Location 1"]
308 #[inline(always)]
309 pub fn loc1(self) -> &'a mut W {
310 self.variant(SDALOC_A::LOC1)
311 }
312 #[doc = "Location 2"]
313 #[inline(always)]
314 pub fn loc2(self) -> &'a mut W {
315 self.variant(SDALOC_A::LOC2)
316 }
317 #[doc = "Location 3"]
318 #[inline(always)]
319 pub fn loc3(self) -> &'a mut W {
320 self.variant(SDALOC_A::LOC3)
321 }
322 #[doc = "Location 4"]
323 #[inline(always)]
324 pub fn loc4(self) -> &'a mut W {
325 self.variant(SDALOC_A::LOC4)
326 }
327 #[doc = "Location 5"]
328 #[inline(always)]
329 pub fn loc5(self) -> &'a mut W {
330 self.variant(SDALOC_A::LOC5)
331 }
332 #[doc = "Location 6"]
333 #[inline(always)]
334 pub fn loc6(self) -> &'a mut W {
335 self.variant(SDALOC_A::LOC6)
336 }
337 #[doc = "Location 7"]
338 #[inline(always)]
339 pub fn loc7(self) -> &'a mut W {
340 self.variant(SDALOC_A::LOC7)
341 }
342 #[doc = "Location 8"]
343 #[inline(always)]
344 pub fn loc8(self) -> &'a mut W {
345 self.variant(SDALOC_A::LOC8)
346 }
347 #[doc = "Location 9"]
348 #[inline(always)]
349 pub fn loc9(self) -> &'a mut W {
350 self.variant(SDALOC_A::LOC9)
351 }
352 #[doc = "Location 10"]
353 #[inline(always)]
354 pub fn loc10(self) -> &'a mut W {
355 self.variant(SDALOC_A::LOC10)
356 }
357 #[doc = "Location 11"]
358 #[inline(always)]
359 pub fn loc11(self) -> &'a mut W {
360 self.variant(SDALOC_A::LOC11)
361 }
362 #[doc = "Location 12"]
363 #[inline(always)]
364 pub fn loc12(self) -> &'a mut W {
365 self.variant(SDALOC_A::LOC12)
366 }
367 #[doc = "Location 13"]
368 #[inline(always)]
369 pub fn loc13(self) -> &'a mut W {
370 self.variant(SDALOC_A::LOC13)
371 }
372 #[doc = "Location 14"]
373 #[inline(always)]
374 pub fn loc14(self) -> &'a mut W {
375 self.variant(SDALOC_A::LOC14)
376 }
377 #[doc = "Location 15"]
378 #[inline(always)]
379 pub fn loc15(self) -> &'a mut W {
380 self.variant(SDALOC_A::LOC15)
381 }
382 #[doc = "Location 16"]
383 #[inline(always)]
384 pub fn loc16(self) -> &'a mut W {
385 self.variant(SDALOC_A::LOC16)
386 }
387 #[doc = "Location 17"]
388 #[inline(always)]
389 pub fn loc17(self) -> &'a mut W {
390 self.variant(SDALOC_A::LOC17)
391 }
392 #[doc = "Location 18"]
393 #[inline(always)]
394 pub fn loc18(self) -> &'a mut W {
395 self.variant(SDALOC_A::LOC18)
396 }
397 #[doc = "Location 19"]
398 #[inline(always)]
399 pub fn loc19(self) -> &'a mut W {
400 self.variant(SDALOC_A::LOC19)
401 }
402 #[doc = "Location 20"]
403 #[inline(always)]
404 pub fn loc20(self) -> &'a mut W {
405 self.variant(SDALOC_A::LOC20)
406 }
407 #[doc = "Location 21"]
408 #[inline(always)]
409 pub fn loc21(self) -> &'a mut W {
410 self.variant(SDALOC_A::LOC21)
411 }
412 #[doc = "Location 22"]
413 #[inline(always)]
414 pub fn loc22(self) -> &'a mut W {
415 self.variant(SDALOC_A::LOC22)
416 }
417 #[doc = "Location 23"]
418 #[inline(always)]
419 pub fn loc23(self) -> &'a mut W {
420 self.variant(SDALOC_A::LOC23)
421 }
422 #[doc = "Location 24"]
423 #[inline(always)]
424 pub fn loc24(self) -> &'a mut W {
425 self.variant(SDALOC_A::LOC24)
426 }
427 #[doc = "Location 25"]
428 #[inline(always)]
429 pub fn loc25(self) -> &'a mut W {
430 self.variant(SDALOC_A::LOC25)
431 }
432 #[doc = "Location 26"]
433 #[inline(always)]
434 pub fn loc26(self) -> &'a mut W {
435 self.variant(SDALOC_A::LOC26)
436 }
437 #[doc = "Location 27"]
438 #[inline(always)]
439 pub fn loc27(self) -> &'a mut W {
440 self.variant(SDALOC_A::LOC27)
441 }
442 #[doc = "Location 28"]
443 #[inline(always)]
444 pub fn loc28(self) -> &'a mut W {
445 self.variant(SDALOC_A::LOC28)
446 }
447 #[doc = "Location 29"]
448 #[inline(always)]
449 pub fn loc29(self) -> &'a mut W {
450 self.variant(SDALOC_A::LOC29)
451 }
452 #[doc = "Location 30"]
453 #[inline(always)]
454 pub fn loc30(self) -> &'a mut W {
455 self.variant(SDALOC_A::LOC30)
456 }
457 #[doc = "Location 31"]
458 #[inline(always)]
459 pub fn loc31(self) -> &'a mut W {
460 self.variant(SDALOC_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 SCLLOC_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<SCLLOC_A> for u8 {
539 #[inline(always)]
540 fn from(variant: SCLLOC_A) -> Self {
541 variant as _
542 }
543}
544#[doc = "Reader of field `SCLLOC`"]
545pub type SCLLOC_R = crate::R<u8, SCLLOC_A>;
546impl SCLLOC_R {
547 #[doc = r"Get enumerated values variant"]
548 #[inline(always)]
549 pub fn variant(&self) -> crate::Variant<u8, SCLLOC_A> {
550 use crate::Variant::*;
551 match self.bits {
552 0 => Val(SCLLOC_A::LOC0),
553 1 => Val(SCLLOC_A::LOC1),
554 2 => Val(SCLLOC_A::LOC2),
555 3 => Val(SCLLOC_A::LOC3),
556 4 => Val(SCLLOC_A::LOC4),
557 5 => Val(SCLLOC_A::LOC5),
558 6 => Val(SCLLOC_A::LOC6),
559 7 => Val(SCLLOC_A::LOC7),
560 8 => Val(SCLLOC_A::LOC8),
561 9 => Val(SCLLOC_A::LOC9),
562 10 => Val(SCLLOC_A::LOC10),
563 11 => Val(SCLLOC_A::LOC11),
564 12 => Val(SCLLOC_A::LOC12),
565 13 => Val(SCLLOC_A::LOC13),
566 14 => Val(SCLLOC_A::LOC14),
567 15 => Val(SCLLOC_A::LOC15),
568 16 => Val(SCLLOC_A::LOC16),
569 17 => Val(SCLLOC_A::LOC17),
570 18 => Val(SCLLOC_A::LOC18),
571 19 => Val(SCLLOC_A::LOC19),
572 20 => Val(SCLLOC_A::LOC20),
573 21 => Val(SCLLOC_A::LOC21),
574 22 => Val(SCLLOC_A::LOC22),
575 23 => Val(SCLLOC_A::LOC23),
576 24 => Val(SCLLOC_A::LOC24),
577 25 => Val(SCLLOC_A::LOC25),
578 26 => Val(SCLLOC_A::LOC26),
579 27 => Val(SCLLOC_A::LOC27),
580 28 => Val(SCLLOC_A::LOC28),
581 29 => Val(SCLLOC_A::LOC29),
582 30 => Val(SCLLOC_A::LOC30),
583 31 => Val(SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_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 == SCLLOC_A::LOC31
746 }
747}
748#[doc = "Write proxy for field `SCLLOC`"]
749pub struct SCLLOC_W<'a> {
750 w: &'a mut W,
751}
752impl<'a> SCLLOC_W<'a> {
753 #[doc = r"Writes `variant` to the field"]
754 #[inline(always)]
755 pub fn variant(self, variant: SCLLOC_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(SCLLOC_A::LOC0)
762 }
763 #[doc = "Location 1"]
764 #[inline(always)]
765 pub fn loc1(self) -> &'a mut W {
766 self.variant(SCLLOC_A::LOC1)
767 }
768 #[doc = "Location 2"]
769 #[inline(always)]
770 pub fn loc2(self) -> &'a mut W {
771 self.variant(SCLLOC_A::LOC2)
772 }
773 #[doc = "Location 3"]
774 #[inline(always)]
775 pub fn loc3(self) -> &'a mut W {
776 self.variant(SCLLOC_A::LOC3)
777 }
778 #[doc = "Location 4"]
779 #[inline(always)]
780 pub fn loc4(self) -> &'a mut W {
781 self.variant(SCLLOC_A::LOC4)
782 }
783 #[doc = "Location 5"]
784 #[inline(always)]
785 pub fn loc5(self) -> &'a mut W {
786 self.variant(SCLLOC_A::LOC5)
787 }
788 #[doc = "Location 6"]
789 #[inline(always)]
790 pub fn loc6(self) -> &'a mut W {
791 self.variant(SCLLOC_A::LOC6)
792 }
793 #[doc = "Location 7"]
794 #[inline(always)]
795 pub fn loc7(self) -> &'a mut W {
796 self.variant(SCLLOC_A::LOC7)
797 }
798 #[doc = "Location 8"]
799 #[inline(always)]
800 pub fn loc8(self) -> &'a mut W {
801 self.variant(SCLLOC_A::LOC8)
802 }
803 #[doc = "Location 9"]
804 #[inline(always)]
805 pub fn loc9(self) -> &'a mut W {
806 self.variant(SCLLOC_A::LOC9)
807 }
808 #[doc = "Location 10"]
809 #[inline(always)]
810 pub fn loc10(self) -> &'a mut W {
811 self.variant(SCLLOC_A::LOC10)
812 }
813 #[doc = "Location 11"]
814 #[inline(always)]
815 pub fn loc11(self) -> &'a mut W {
816 self.variant(SCLLOC_A::LOC11)
817 }
818 #[doc = "Location 12"]
819 #[inline(always)]
820 pub fn loc12(self) -> &'a mut W {
821 self.variant(SCLLOC_A::LOC12)
822 }
823 #[doc = "Location 13"]
824 #[inline(always)]
825 pub fn loc13(self) -> &'a mut W {
826 self.variant(SCLLOC_A::LOC13)
827 }
828 #[doc = "Location 14"]
829 #[inline(always)]
830 pub fn loc14(self) -> &'a mut W {
831 self.variant(SCLLOC_A::LOC14)
832 }
833 #[doc = "Location 15"]
834 #[inline(always)]
835 pub fn loc15(self) -> &'a mut W {
836 self.variant(SCLLOC_A::LOC15)
837 }
838 #[doc = "Location 16"]
839 #[inline(always)]
840 pub fn loc16(self) -> &'a mut W {
841 self.variant(SCLLOC_A::LOC16)
842 }
843 #[doc = "Location 17"]
844 #[inline(always)]
845 pub fn loc17(self) -> &'a mut W {
846 self.variant(SCLLOC_A::LOC17)
847 }
848 #[doc = "Location 18"]
849 #[inline(always)]
850 pub fn loc18(self) -> &'a mut W {
851 self.variant(SCLLOC_A::LOC18)
852 }
853 #[doc = "Location 19"]
854 #[inline(always)]
855 pub fn loc19(self) -> &'a mut W {
856 self.variant(SCLLOC_A::LOC19)
857 }
858 #[doc = "Location 20"]
859 #[inline(always)]
860 pub fn loc20(self) -> &'a mut W {
861 self.variant(SCLLOC_A::LOC20)
862 }
863 #[doc = "Location 21"]
864 #[inline(always)]
865 pub fn loc21(self) -> &'a mut W {
866 self.variant(SCLLOC_A::LOC21)
867 }
868 #[doc = "Location 22"]
869 #[inline(always)]
870 pub fn loc22(self) -> &'a mut W {
871 self.variant(SCLLOC_A::LOC22)
872 }
873 #[doc = "Location 23"]
874 #[inline(always)]
875 pub fn loc23(self) -> &'a mut W {
876 self.variant(SCLLOC_A::LOC23)
877 }
878 #[doc = "Location 24"]
879 #[inline(always)]
880 pub fn loc24(self) -> &'a mut W {
881 self.variant(SCLLOC_A::LOC24)
882 }
883 #[doc = "Location 25"]
884 #[inline(always)]
885 pub fn loc25(self) -> &'a mut W {
886 self.variant(SCLLOC_A::LOC25)
887 }
888 #[doc = "Location 26"]
889 #[inline(always)]
890 pub fn loc26(self) -> &'a mut W {
891 self.variant(SCLLOC_A::LOC26)
892 }
893 #[doc = "Location 27"]
894 #[inline(always)]
895 pub fn loc27(self) -> &'a mut W {
896 self.variant(SCLLOC_A::LOC27)
897 }
898 #[doc = "Location 28"]
899 #[inline(always)]
900 pub fn loc28(self) -> &'a mut W {
901 self.variant(SCLLOC_A::LOC28)
902 }
903 #[doc = "Location 29"]
904 #[inline(always)]
905 pub fn loc29(self) -> &'a mut W {
906 self.variant(SCLLOC_A::LOC29)
907 }
908 #[doc = "Location 30"]
909 #[inline(always)]
910 pub fn loc30(self) -> &'a mut W {
911 self.variant(SCLLOC_A::LOC30)
912 }
913 #[doc = "Location 31"]
914 #[inline(always)]
915 pub fn loc31(self) -> &'a mut W {
916 self.variant(SCLLOC_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}
925impl R {
926 #[doc = "Bits 0:5 - I/O Location"]
927 #[inline(always)]
928 pub fn sdaloc(&self) -> SDALOC_R {
929 SDALOC_R::new((self.bits & 0x3f) as u8)
930 }
931 #[doc = "Bits 8:13 - I/O Location"]
932 #[inline(always)]
933 pub fn sclloc(&self) -> SCLLOC_R {
934 SCLLOC_R::new(((self.bits >> 8) & 0x3f) as u8)
935 }
936}
937impl W {
938 #[doc = "Bits 0:5 - I/O Location"]
939 #[inline(always)]
940 pub fn sdaloc(&mut self) -> SDALOC_W {
941 SDALOC_W { w: self }
942 }
943 #[doc = "Bits 8:13 - I/O Location"]
944 #[inline(always)]
945 pub fn sclloc(&mut self) -> SCLLOC_W {
946 SCLLOC_W { w: self }
947 }
948}