efm32jg12b_pac/efm32jg12b500/i2c1/
routeloc0.rs1#[doc = "Register `ROUTELOC0` reader"]
2pub struct R(crate::R<ROUTELOC0_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<ROUTELOC0_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<ROUTELOC0_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<ROUTELOC0_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `ROUTELOC0` writer"]
17pub struct W(crate::W<ROUTELOC0_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<ROUTELOC0_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<ROUTELOC0_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<ROUTELOC0_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `SDALOC` reader - I/O Location"]
38pub type SDALOC_R = crate::FieldReader<u8, SDALOC_A>;
39#[doc = "I/O Location\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum SDALOC_A {
43 #[doc = "0: Location 0"]
44 LOC0 = 0,
45 #[doc = "1: Location 1"]
46 LOC1 = 1,
47 #[doc = "2: Location 2"]
48 LOC2 = 2,
49 #[doc = "3: Location 3"]
50 LOC3 = 3,
51 #[doc = "4: Location 4"]
52 LOC4 = 4,
53 #[doc = "5: Location 5"]
54 LOC5 = 5,
55 #[doc = "6: Location 6"]
56 LOC6 = 6,
57 #[doc = "7: Location 7"]
58 LOC7 = 7,
59 #[doc = "8: Location 8"]
60 LOC8 = 8,
61 #[doc = "9: Location 9"]
62 LOC9 = 9,
63 #[doc = "10: Location 10"]
64 LOC10 = 10,
65 #[doc = "11: Location 11"]
66 LOC11 = 11,
67 #[doc = "12: Location 12"]
68 LOC12 = 12,
69 #[doc = "13: Location 13"]
70 LOC13 = 13,
71 #[doc = "14: Location 14"]
72 LOC14 = 14,
73 #[doc = "15: Location 15"]
74 LOC15 = 15,
75 #[doc = "16: Location 16"]
76 LOC16 = 16,
77 #[doc = "17: Location 17"]
78 LOC17 = 17,
79 #[doc = "18: Location 18"]
80 LOC18 = 18,
81 #[doc = "19: Location 19"]
82 LOC19 = 19,
83 #[doc = "20: Location 20"]
84 LOC20 = 20,
85 #[doc = "21: Location 21"]
86 LOC21 = 21,
87 #[doc = "22: Location 22"]
88 LOC22 = 22,
89 #[doc = "23: Location 23"]
90 LOC23 = 23,
91 #[doc = "24: Location 24"]
92 LOC24 = 24,
93 #[doc = "25: Location 25"]
94 LOC25 = 25,
95 #[doc = "26: Location 26"]
96 LOC26 = 26,
97 #[doc = "27: Location 27"]
98 LOC27 = 27,
99 #[doc = "28: Location 28"]
100 LOC28 = 28,
101 #[doc = "29: Location 29"]
102 LOC29 = 29,
103 #[doc = "30: Location 30"]
104 LOC30 = 30,
105 #[doc = "31: Location 31"]
106 LOC31 = 31,
107}
108impl From<SDALOC_A> for u8 {
109 #[inline(always)]
110 fn from(variant: SDALOC_A) -> Self {
111 variant as _
112 }
113}
114impl SDALOC_R {
115 #[doc = "Get enumerated values variant"]
116 #[inline(always)]
117 pub fn variant(&self) -> Option<SDALOC_A> {
118 match self.bits {
119 0 => Some(SDALOC_A::LOC0),
120 1 => Some(SDALOC_A::LOC1),
121 2 => Some(SDALOC_A::LOC2),
122 3 => Some(SDALOC_A::LOC3),
123 4 => Some(SDALOC_A::LOC4),
124 5 => Some(SDALOC_A::LOC5),
125 6 => Some(SDALOC_A::LOC6),
126 7 => Some(SDALOC_A::LOC7),
127 8 => Some(SDALOC_A::LOC8),
128 9 => Some(SDALOC_A::LOC9),
129 10 => Some(SDALOC_A::LOC10),
130 11 => Some(SDALOC_A::LOC11),
131 12 => Some(SDALOC_A::LOC12),
132 13 => Some(SDALOC_A::LOC13),
133 14 => Some(SDALOC_A::LOC14),
134 15 => Some(SDALOC_A::LOC15),
135 16 => Some(SDALOC_A::LOC16),
136 17 => Some(SDALOC_A::LOC17),
137 18 => Some(SDALOC_A::LOC18),
138 19 => Some(SDALOC_A::LOC19),
139 20 => Some(SDALOC_A::LOC20),
140 21 => Some(SDALOC_A::LOC21),
141 22 => Some(SDALOC_A::LOC22),
142 23 => Some(SDALOC_A::LOC23),
143 24 => Some(SDALOC_A::LOC24),
144 25 => Some(SDALOC_A::LOC25),
145 26 => Some(SDALOC_A::LOC26),
146 27 => Some(SDALOC_A::LOC27),
147 28 => Some(SDALOC_A::LOC28),
148 29 => Some(SDALOC_A::LOC29),
149 30 => Some(SDALOC_A::LOC30),
150 31 => Some(SDALOC_A::LOC31),
151 _ => None,
152 }
153 }
154 #[doc = "Checks if the value of the field is `LOC0`"]
155 #[inline(always)]
156 pub fn is_loc0(&self) -> bool {
157 *self == SDALOC_A::LOC0
158 }
159 #[doc = "Checks if the value of the field is `LOC1`"]
160 #[inline(always)]
161 pub fn is_loc1(&self) -> bool {
162 *self == SDALOC_A::LOC1
163 }
164 #[doc = "Checks if the value of the field is `LOC2`"]
165 #[inline(always)]
166 pub fn is_loc2(&self) -> bool {
167 *self == SDALOC_A::LOC2
168 }
169 #[doc = "Checks if the value of the field is `LOC3`"]
170 #[inline(always)]
171 pub fn is_loc3(&self) -> bool {
172 *self == SDALOC_A::LOC3
173 }
174 #[doc = "Checks if the value of the field is `LOC4`"]
175 #[inline(always)]
176 pub fn is_loc4(&self) -> bool {
177 *self == SDALOC_A::LOC4
178 }
179 #[doc = "Checks if the value of the field is `LOC5`"]
180 #[inline(always)]
181 pub fn is_loc5(&self) -> bool {
182 *self == SDALOC_A::LOC5
183 }
184 #[doc = "Checks if the value of the field is `LOC6`"]
185 #[inline(always)]
186 pub fn is_loc6(&self) -> bool {
187 *self == SDALOC_A::LOC6
188 }
189 #[doc = "Checks if the value of the field is `LOC7`"]
190 #[inline(always)]
191 pub fn is_loc7(&self) -> bool {
192 *self == SDALOC_A::LOC7
193 }
194 #[doc = "Checks if the value of the field is `LOC8`"]
195 #[inline(always)]
196 pub fn is_loc8(&self) -> bool {
197 *self == SDALOC_A::LOC8
198 }
199 #[doc = "Checks if the value of the field is `LOC9`"]
200 #[inline(always)]
201 pub fn is_loc9(&self) -> bool {
202 *self == SDALOC_A::LOC9
203 }
204 #[doc = "Checks if the value of the field is `LOC10`"]
205 #[inline(always)]
206 pub fn is_loc10(&self) -> bool {
207 *self == SDALOC_A::LOC10
208 }
209 #[doc = "Checks if the value of the field is `LOC11`"]
210 #[inline(always)]
211 pub fn is_loc11(&self) -> bool {
212 *self == SDALOC_A::LOC11
213 }
214 #[doc = "Checks if the value of the field is `LOC12`"]
215 #[inline(always)]
216 pub fn is_loc12(&self) -> bool {
217 *self == SDALOC_A::LOC12
218 }
219 #[doc = "Checks if the value of the field is `LOC13`"]
220 #[inline(always)]
221 pub fn is_loc13(&self) -> bool {
222 *self == SDALOC_A::LOC13
223 }
224 #[doc = "Checks if the value of the field is `LOC14`"]
225 #[inline(always)]
226 pub fn is_loc14(&self) -> bool {
227 *self == SDALOC_A::LOC14
228 }
229 #[doc = "Checks if the value of the field is `LOC15`"]
230 #[inline(always)]
231 pub fn is_loc15(&self) -> bool {
232 *self == SDALOC_A::LOC15
233 }
234 #[doc = "Checks if the value of the field is `LOC16`"]
235 #[inline(always)]
236 pub fn is_loc16(&self) -> bool {
237 *self == SDALOC_A::LOC16
238 }
239 #[doc = "Checks if the value of the field is `LOC17`"]
240 #[inline(always)]
241 pub fn is_loc17(&self) -> bool {
242 *self == SDALOC_A::LOC17
243 }
244 #[doc = "Checks if the value of the field is `LOC18`"]
245 #[inline(always)]
246 pub fn is_loc18(&self) -> bool {
247 *self == SDALOC_A::LOC18
248 }
249 #[doc = "Checks if the value of the field is `LOC19`"]
250 #[inline(always)]
251 pub fn is_loc19(&self) -> bool {
252 *self == SDALOC_A::LOC19
253 }
254 #[doc = "Checks if the value of the field is `LOC20`"]
255 #[inline(always)]
256 pub fn is_loc20(&self) -> bool {
257 *self == SDALOC_A::LOC20
258 }
259 #[doc = "Checks if the value of the field is `LOC21`"]
260 #[inline(always)]
261 pub fn is_loc21(&self) -> bool {
262 *self == SDALOC_A::LOC21
263 }
264 #[doc = "Checks if the value of the field is `LOC22`"]
265 #[inline(always)]
266 pub fn is_loc22(&self) -> bool {
267 *self == SDALOC_A::LOC22
268 }
269 #[doc = "Checks if the value of the field is `LOC23`"]
270 #[inline(always)]
271 pub fn is_loc23(&self) -> bool {
272 *self == SDALOC_A::LOC23
273 }
274 #[doc = "Checks if the value of the field is `LOC24`"]
275 #[inline(always)]
276 pub fn is_loc24(&self) -> bool {
277 *self == SDALOC_A::LOC24
278 }
279 #[doc = "Checks if the value of the field is `LOC25`"]
280 #[inline(always)]
281 pub fn is_loc25(&self) -> bool {
282 *self == SDALOC_A::LOC25
283 }
284 #[doc = "Checks if the value of the field is `LOC26`"]
285 #[inline(always)]
286 pub fn is_loc26(&self) -> bool {
287 *self == SDALOC_A::LOC26
288 }
289 #[doc = "Checks if the value of the field is `LOC27`"]
290 #[inline(always)]
291 pub fn is_loc27(&self) -> bool {
292 *self == SDALOC_A::LOC27
293 }
294 #[doc = "Checks if the value of the field is `LOC28`"]
295 #[inline(always)]
296 pub fn is_loc28(&self) -> bool {
297 *self == SDALOC_A::LOC28
298 }
299 #[doc = "Checks if the value of the field is `LOC29`"]
300 #[inline(always)]
301 pub fn is_loc29(&self) -> bool {
302 *self == SDALOC_A::LOC29
303 }
304 #[doc = "Checks if the value of the field is `LOC30`"]
305 #[inline(always)]
306 pub fn is_loc30(&self) -> bool {
307 *self == SDALOC_A::LOC30
308 }
309 #[doc = "Checks if the value of the field is `LOC31`"]
310 #[inline(always)]
311 pub fn is_loc31(&self) -> bool {
312 *self == SDALOC_A::LOC31
313 }
314}
315#[doc = "Field `SDALOC` writer - I/O Location"]
316pub type SDALOC_W<'a, const O: u8> =
317 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, SDALOC_A, 6, O>;
318impl<'a, const O: u8> SDALOC_W<'a, O> {
319 #[doc = "Location 0"]
320 #[inline(always)]
321 pub fn loc0(self) -> &'a mut W {
322 self.variant(SDALOC_A::LOC0)
323 }
324 #[doc = "Location 1"]
325 #[inline(always)]
326 pub fn loc1(self) -> &'a mut W {
327 self.variant(SDALOC_A::LOC1)
328 }
329 #[doc = "Location 2"]
330 #[inline(always)]
331 pub fn loc2(self) -> &'a mut W {
332 self.variant(SDALOC_A::LOC2)
333 }
334 #[doc = "Location 3"]
335 #[inline(always)]
336 pub fn loc3(self) -> &'a mut W {
337 self.variant(SDALOC_A::LOC3)
338 }
339 #[doc = "Location 4"]
340 #[inline(always)]
341 pub fn loc4(self) -> &'a mut W {
342 self.variant(SDALOC_A::LOC4)
343 }
344 #[doc = "Location 5"]
345 #[inline(always)]
346 pub fn loc5(self) -> &'a mut W {
347 self.variant(SDALOC_A::LOC5)
348 }
349 #[doc = "Location 6"]
350 #[inline(always)]
351 pub fn loc6(self) -> &'a mut W {
352 self.variant(SDALOC_A::LOC6)
353 }
354 #[doc = "Location 7"]
355 #[inline(always)]
356 pub fn loc7(self) -> &'a mut W {
357 self.variant(SDALOC_A::LOC7)
358 }
359 #[doc = "Location 8"]
360 #[inline(always)]
361 pub fn loc8(self) -> &'a mut W {
362 self.variant(SDALOC_A::LOC8)
363 }
364 #[doc = "Location 9"]
365 #[inline(always)]
366 pub fn loc9(self) -> &'a mut W {
367 self.variant(SDALOC_A::LOC9)
368 }
369 #[doc = "Location 10"]
370 #[inline(always)]
371 pub fn loc10(self) -> &'a mut W {
372 self.variant(SDALOC_A::LOC10)
373 }
374 #[doc = "Location 11"]
375 #[inline(always)]
376 pub fn loc11(self) -> &'a mut W {
377 self.variant(SDALOC_A::LOC11)
378 }
379 #[doc = "Location 12"]
380 #[inline(always)]
381 pub fn loc12(self) -> &'a mut W {
382 self.variant(SDALOC_A::LOC12)
383 }
384 #[doc = "Location 13"]
385 #[inline(always)]
386 pub fn loc13(self) -> &'a mut W {
387 self.variant(SDALOC_A::LOC13)
388 }
389 #[doc = "Location 14"]
390 #[inline(always)]
391 pub fn loc14(self) -> &'a mut W {
392 self.variant(SDALOC_A::LOC14)
393 }
394 #[doc = "Location 15"]
395 #[inline(always)]
396 pub fn loc15(self) -> &'a mut W {
397 self.variant(SDALOC_A::LOC15)
398 }
399 #[doc = "Location 16"]
400 #[inline(always)]
401 pub fn loc16(self) -> &'a mut W {
402 self.variant(SDALOC_A::LOC16)
403 }
404 #[doc = "Location 17"]
405 #[inline(always)]
406 pub fn loc17(self) -> &'a mut W {
407 self.variant(SDALOC_A::LOC17)
408 }
409 #[doc = "Location 18"]
410 #[inline(always)]
411 pub fn loc18(self) -> &'a mut W {
412 self.variant(SDALOC_A::LOC18)
413 }
414 #[doc = "Location 19"]
415 #[inline(always)]
416 pub fn loc19(self) -> &'a mut W {
417 self.variant(SDALOC_A::LOC19)
418 }
419 #[doc = "Location 20"]
420 #[inline(always)]
421 pub fn loc20(self) -> &'a mut W {
422 self.variant(SDALOC_A::LOC20)
423 }
424 #[doc = "Location 21"]
425 #[inline(always)]
426 pub fn loc21(self) -> &'a mut W {
427 self.variant(SDALOC_A::LOC21)
428 }
429 #[doc = "Location 22"]
430 #[inline(always)]
431 pub fn loc22(self) -> &'a mut W {
432 self.variant(SDALOC_A::LOC22)
433 }
434 #[doc = "Location 23"]
435 #[inline(always)]
436 pub fn loc23(self) -> &'a mut W {
437 self.variant(SDALOC_A::LOC23)
438 }
439 #[doc = "Location 24"]
440 #[inline(always)]
441 pub fn loc24(self) -> &'a mut W {
442 self.variant(SDALOC_A::LOC24)
443 }
444 #[doc = "Location 25"]
445 #[inline(always)]
446 pub fn loc25(self) -> &'a mut W {
447 self.variant(SDALOC_A::LOC25)
448 }
449 #[doc = "Location 26"]
450 #[inline(always)]
451 pub fn loc26(self) -> &'a mut W {
452 self.variant(SDALOC_A::LOC26)
453 }
454 #[doc = "Location 27"]
455 #[inline(always)]
456 pub fn loc27(self) -> &'a mut W {
457 self.variant(SDALOC_A::LOC27)
458 }
459 #[doc = "Location 28"]
460 #[inline(always)]
461 pub fn loc28(self) -> &'a mut W {
462 self.variant(SDALOC_A::LOC28)
463 }
464 #[doc = "Location 29"]
465 #[inline(always)]
466 pub fn loc29(self) -> &'a mut W {
467 self.variant(SDALOC_A::LOC29)
468 }
469 #[doc = "Location 30"]
470 #[inline(always)]
471 pub fn loc30(self) -> &'a mut W {
472 self.variant(SDALOC_A::LOC30)
473 }
474 #[doc = "Location 31"]
475 #[inline(always)]
476 pub fn loc31(self) -> &'a mut W {
477 self.variant(SDALOC_A::LOC31)
478 }
479}
480#[doc = "Field `SCLLOC` reader - I/O Location"]
481pub type SCLLOC_R = crate::FieldReader<u8, SCLLOC_A>;
482#[doc = "I/O Location\n\nValue on reset: 0"]
483#[derive(Clone, Copy, Debug, PartialEq, Eq)]
484#[repr(u8)]
485pub enum SCLLOC_A {
486 #[doc = "0: Location 0"]
487 LOC0 = 0,
488 #[doc = "1: Location 1"]
489 LOC1 = 1,
490 #[doc = "2: Location 2"]
491 LOC2 = 2,
492 #[doc = "3: Location 3"]
493 LOC3 = 3,
494 #[doc = "4: Location 4"]
495 LOC4 = 4,
496 #[doc = "5: Location 5"]
497 LOC5 = 5,
498 #[doc = "6: Location 6"]
499 LOC6 = 6,
500 #[doc = "7: Location 7"]
501 LOC7 = 7,
502 #[doc = "8: Location 8"]
503 LOC8 = 8,
504 #[doc = "9: Location 9"]
505 LOC9 = 9,
506 #[doc = "10: Location 10"]
507 LOC10 = 10,
508 #[doc = "11: Location 11"]
509 LOC11 = 11,
510 #[doc = "12: Location 12"]
511 LOC12 = 12,
512 #[doc = "13: Location 13"]
513 LOC13 = 13,
514 #[doc = "14: Location 14"]
515 LOC14 = 14,
516 #[doc = "15: Location 15"]
517 LOC15 = 15,
518 #[doc = "16: Location 16"]
519 LOC16 = 16,
520 #[doc = "17: Location 17"]
521 LOC17 = 17,
522 #[doc = "18: Location 18"]
523 LOC18 = 18,
524 #[doc = "19: Location 19"]
525 LOC19 = 19,
526 #[doc = "20: Location 20"]
527 LOC20 = 20,
528 #[doc = "21: Location 21"]
529 LOC21 = 21,
530 #[doc = "22: Location 22"]
531 LOC22 = 22,
532 #[doc = "23: Location 23"]
533 LOC23 = 23,
534 #[doc = "24: Location 24"]
535 LOC24 = 24,
536 #[doc = "25: Location 25"]
537 LOC25 = 25,
538 #[doc = "26: Location 26"]
539 LOC26 = 26,
540 #[doc = "27: Location 27"]
541 LOC27 = 27,
542 #[doc = "28: Location 28"]
543 LOC28 = 28,
544 #[doc = "29: Location 29"]
545 LOC29 = 29,
546 #[doc = "30: Location 30"]
547 LOC30 = 30,
548 #[doc = "31: Location 31"]
549 LOC31 = 31,
550}
551impl From<SCLLOC_A> for u8 {
552 #[inline(always)]
553 fn from(variant: SCLLOC_A) -> Self {
554 variant as _
555 }
556}
557impl SCLLOC_R {
558 #[doc = "Get enumerated values variant"]
559 #[inline(always)]
560 pub fn variant(&self) -> Option<SCLLOC_A> {
561 match self.bits {
562 0 => Some(SCLLOC_A::LOC0),
563 1 => Some(SCLLOC_A::LOC1),
564 2 => Some(SCLLOC_A::LOC2),
565 3 => Some(SCLLOC_A::LOC3),
566 4 => Some(SCLLOC_A::LOC4),
567 5 => Some(SCLLOC_A::LOC5),
568 6 => Some(SCLLOC_A::LOC6),
569 7 => Some(SCLLOC_A::LOC7),
570 8 => Some(SCLLOC_A::LOC8),
571 9 => Some(SCLLOC_A::LOC9),
572 10 => Some(SCLLOC_A::LOC10),
573 11 => Some(SCLLOC_A::LOC11),
574 12 => Some(SCLLOC_A::LOC12),
575 13 => Some(SCLLOC_A::LOC13),
576 14 => Some(SCLLOC_A::LOC14),
577 15 => Some(SCLLOC_A::LOC15),
578 16 => Some(SCLLOC_A::LOC16),
579 17 => Some(SCLLOC_A::LOC17),
580 18 => Some(SCLLOC_A::LOC18),
581 19 => Some(SCLLOC_A::LOC19),
582 20 => Some(SCLLOC_A::LOC20),
583 21 => Some(SCLLOC_A::LOC21),
584 22 => Some(SCLLOC_A::LOC22),
585 23 => Some(SCLLOC_A::LOC23),
586 24 => Some(SCLLOC_A::LOC24),
587 25 => Some(SCLLOC_A::LOC25),
588 26 => Some(SCLLOC_A::LOC26),
589 27 => Some(SCLLOC_A::LOC27),
590 28 => Some(SCLLOC_A::LOC28),
591 29 => Some(SCLLOC_A::LOC29),
592 30 => Some(SCLLOC_A::LOC30),
593 31 => Some(SCLLOC_A::LOC31),
594 _ => None,
595 }
596 }
597 #[doc = "Checks if the value of the field is `LOC0`"]
598 #[inline(always)]
599 pub fn is_loc0(&self) -> bool {
600 *self == SCLLOC_A::LOC0
601 }
602 #[doc = "Checks if the value of the field is `LOC1`"]
603 #[inline(always)]
604 pub fn is_loc1(&self) -> bool {
605 *self == SCLLOC_A::LOC1
606 }
607 #[doc = "Checks if the value of the field is `LOC2`"]
608 #[inline(always)]
609 pub fn is_loc2(&self) -> bool {
610 *self == SCLLOC_A::LOC2
611 }
612 #[doc = "Checks if the value of the field is `LOC3`"]
613 #[inline(always)]
614 pub fn is_loc3(&self) -> bool {
615 *self == SCLLOC_A::LOC3
616 }
617 #[doc = "Checks if the value of the field is `LOC4`"]
618 #[inline(always)]
619 pub fn is_loc4(&self) -> bool {
620 *self == SCLLOC_A::LOC4
621 }
622 #[doc = "Checks if the value of the field is `LOC5`"]
623 #[inline(always)]
624 pub fn is_loc5(&self) -> bool {
625 *self == SCLLOC_A::LOC5
626 }
627 #[doc = "Checks if the value of the field is `LOC6`"]
628 #[inline(always)]
629 pub fn is_loc6(&self) -> bool {
630 *self == SCLLOC_A::LOC6
631 }
632 #[doc = "Checks if the value of the field is `LOC7`"]
633 #[inline(always)]
634 pub fn is_loc7(&self) -> bool {
635 *self == SCLLOC_A::LOC7
636 }
637 #[doc = "Checks if the value of the field is `LOC8`"]
638 #[inline(always)]
639 pub fn is_loc8(&self) -> bool {
640 *self == SCLLOC_A::LOC8
641 }
642 #[doc = "Checks if the value of the field is `LOC9`"]
643 #[inline(always)]
644 pub fn is_loc9(&self) -> bool {
645 *self == SCLLOC_A::LOC9
646 }
647 #[doc = "Checks if the value of the field is `LOC10`"]
648 #[inline(always)]
649 pub fn is_loc10(&self) -> bool {
650 *self == SCLLOC_A::LOC10
651 }
652 #[doc = "Checks if the value of the field is `LOC11`"]
653 #[inline(always)]
654 pub fn is_loc11(&self) -> bool {
655 *self == SCLLOC_A::LOC11
656 }
657 #[doc = "Checks if the value of the field is `LOC12`"]
658 #[inline(always)]
659 pub fn is_loc12(&self) -> bool {
660 *self == SCLLOC_A::LOC12
661 }
662 #[doc = "Checks if the value of the field is `LOC13`"]
663 #[inline(always)]
664 pub fn is_loc13(&self) -> bool {
665 *self == SCLLOC_A::LOC13
666 }
667 #[doc = "Checks if the value of the field is `LOC14`"]
668 #[inline(always)]
669 pub fn is_loc14(&self) -> bool {
670 *self == SCLLOC_A::LOC14
671 }
672 #[doc = "Checks if the value of the field is `LOC15`"]
673 #[inline(always)]
674 pub fn is_loc15(&self) -> bool {
675 *self == SCLLOC_A::LOC15
676 }
677 #[doc = "Checks if the value of the field is `LOC16`"]
678 #[inline(always)]
679 pub fn is_loc16(&self) -> bool {
680 *self == SCLLOC_A::LOC16
681 }
682 #[doc = "Checks if the value of the field is `LOC17`"]
683 #[inline(always)]
684 pub fn is_loc17(&self) -> bool {
685 *self == SCLLOC_A::LOC17
686 }
687 #[doc = "Checks if the value of the field is `LOC18`"]
688 #[inline(always)]
689 pub fn is_loc18(&self) -> bool {
690 *self == SCLLOC_A::LOC18
691 }
692 #[doc = "Checks if the value of the field is `LOC19`"]
693 #[inline(always)]
694 pub fn is_loc19(&self) -> bool {
695 *self == SCLLOC_A::LOC19
696 }
697 #[doc = "Checks if the value of the field is `LOC20`"]
698 #[inline(always)]
699 pub fn is_loc20(&self) -> bool {
700 *self == SCLLOC_A::LOC20
701 }
702 #[doc = "Checks if the value of the field is `LOC21`"]
703 #[inline(always)]
704 pub fn is_loc21(&self) -> bool {
705 *self == SCLLOC_A::LOC21
706 }
707 #[doc = "Checks if the value of the field is `LOC22`"]
708 #[inline(always)]
709 pub fn is_loc22(&self) -> bool {
710 *self == SCLLOC_A::LOC22
711 }
712 #[doc = "Checks if the value of the field is `LOC23`"]
713 #[inline(always)]
714 pub fn is_loc23(&self) -> bool {
715 *self == SCLLOC_A::LOC23
716 }
717 #[doc = "Checks if the value of the field is `LOC24`"]
718 #[inline(always)]
719 pub fn is_loc24(&self) -> bool {
720 *self == SCLLOC_A::LOC24
721 }
722 #[doc = "Checks if the value of the field is `LOC25`"]
723 #[inline(always)]
724 pub fn is_loc25(&self) -> bool {
725 *self == SCLLOC_A::LOC25
726 }
727 #[doc = "Checks if the value of the field is `LOC26`"]
728 #[inline(always)]
729 pub fn is_loc26(&self) -> bool {
730 *self == SCLLOC_A::LOC26
731 }
732 #[doc = "Checks if the value of the field is `LOC27`"]
733 #[inline(always)]
734 pub fn is_loc27(&self) -> bool {
735 *self == SCLLOC_A::LOC27
736 }
737 #[doc = "Checks if the value of the field is `LOC28`"]
738 #[inline(always)]
739 pub fn is_loc28(&self) -> bool {
740 *self == SCLLOC_A::LOC28
741 }
742 #[doc = "Checks if the value of the field is `LOC29`"]
743 #[inline(always)]
744 pub fn is_loc29(&self) -> bool {
745 *self == SCLLOC_A::LOC29
746 }
747 #[doc = "Checks if the value of the field is `LOC30`"]
748 #[inline(always)]
749 pub fn is_loc30(&self) -> bool {
750 *self == SCLLOC_A::LOC30
751 }
752 #[doc = "Checks if the value of the field is `LOC31`"]
753 #[inline(always)]
754 pub fn is_loc31(&self) -> bool {
755 *self == SCLLOC_A::LOC31
756 }
757}
758#[doc = "Field `SCLLOC` writer - I/O Location"]
759pub type SCLLOC_W<'a, const O: u8> =
760 crate::FieldWriter<'a, u32, ROUTELOC0_SPEC, u8, SCLLOC_A, 6, O>;
761impl<'a, const O: u8> SCLLOC_W<'a, O> {
762 #[doc = "Location 0"]
763 #[inline(always)]
764 pub fn loc0(self) -> &'a mut W {
765 self.variant(SCLLOC_A::LOC0)
766 }
767 #[doc = "Location 1"]
768 #[inline(always)]
769 pub fn loc1(self) -> &'a mut W {
770 self.variant(SCLLOC_A::LOC1)
771 }
772 #[doc = "Location 2"]
773 #[inline(always)]
774 pub fn loc2(self) -> &'a mut W {
775 self.variant(SCLLOC_A::LOC2)
776 }
777 #[doc = "Location 3"]
778 #[inline(always)]
779 pub fn loc3(self) -> &'a mut W {
780 self.variant(SCLLOC_A::LOC3)
781 }
782 #[doc = "Location 4"]
783 #[inline(always)]
784 pub fn loc4(self) -> &'a mut W {
785 self.variant(SCLLOC_A::LOC4)
786 }
787 #[doc = "Location 5"]
788 #[inline(always)]
789 pub fn loc5(self) -> &'a mut W {
790 self.variant(SCLLOC_A::LOC5)
791 }
792 #[doc = "Location 6"]
793 #[inline(always)]
794 pub fn loc6(self) -> &'a mut W {
795 self.variant(SCLLOC_A::LOC6)
796 }
797 #[doc = "Location 7"]
798 #[inline(always)]
799 pub fn loc7(self) -> &'a mut W {
800 self.variant(SCLLOC_A::LOC7)
801 }
802 #[doc = "Location 8"]
803 #[inline(always)]
804 pub fn loc8(self) -> &'a mut W {
805 self.variant(SCLLOC_A::LOC8)
806 }
807 #[doc = "Location 9"]
808 #[inline(always)]
809 pub fn loc9(self) -> &'a mut W {
810 self.variant(SCLLOC_A::LOC9)
811 }
812 #[doc = "Location 10"]
813 #[inline(always)]
814 pub fn loc10(self) -> &'a mut W {
815 self.variant(SCLLOC_A::LOC10)
816 }
817 #[doc = "Location 11"]
818 #[inline(always)]
819 pub fn loc11(self) -> &'a mut W {
820 self.variant(SCLLOC_A::LOC11)
821 }
822 #[doc = "Location 12"]
823 #[inline(always)]
824 pub fn loc12(self) -> &'a mut W {
825 self.variant(SCLLOC_A::LOC12)
826 }
827 #[doc = "Location 13"]
828 #[inline(always)]
829 pub fn loc13(self) -> &'a mut W {
830 self.variant(SCLLOC_A::LOC13)
831 }
832 #[doc = "Location 14"]
833 #[inline(always)]
834 pub fn loc14(self) -> &'a mut W {
835 self.variant(SCLLOC_A::LOC14)
836 }
837 #[doc = "Location 15"]
838 #[inline(always)]
839 pub fn loc15(self) -> &'a mut W {
840 self.variant(SCLLOC_A::LOC15)
841 }
842 #[doc = "Location 16"]
843 #[inline(always)]
844 pub fn loc16(self) -> &'a mut W {
845 self.variant(SCLLOC_A::LOC16)
846 }
847 #[doc = "Location 17"]
848 #[inline(always)]
849 pub fn loc17(self) -> &'a mut W {
850 self.variant(SCLLOC_A::LOC17)
851 }
852 #[doc = "Location 18"]
853 #[inline(always)]
854 pub fn loc18(self) -> &'a mut W {
855 self.variant(SCLLOC_A::LOC18)
856 }
857 #[doc = "Location 19"]
858 #[inline(always)]
859 pub fn loc19(self) -> &'a mut W {
860 self.variant(SCLLOC_A::LOC19)
861 }
862 #[doc = "Location 20"]
863 #[inline(always)]
864 pub fn loc20(self) -> &'a mut W {
865 self.variant(SCLLOC_A::LOC20)
866 }
867 #[doc = "Location 21"]
868 #[inline(always)]
869 pub fn loc21(self) -> &'a mut W {
870 self.variant(SCLLOC_A::LOC21)
871 }
872 #[doc = "Location 22"]
873 #[inline(always)]
874 pub fn loc22(self) -> &'a mut W {
875 self.variant(SCLLOC_A::LOC22)
876 }
877 #[doc = "Location 23"]
878 #[inline(always)]
879 pub fn loc23(self) -> &'a mut W {
880 self.variant(SCLLOC_A::LOC23)
881 }
882 #[doc = "Location 24"]
883 #[inline(always)]
884 pub fn loc24(self) -> &'a mut W {
885 self.variant(SCLLOC_A::LOC24)
886 }
887 #[doc = "Location 25"]
888 #[inline(always)]
889 pub fn loc25(self) -> &'a mut W {
890 self.variant(SCLLOC_A::LOC25)
891 }
892 #[doc = "Location 26"]
893 #[inline(always)]
894 pub fn loc26(self) -> &'a mut W {
895 self.variant(SCLLOC_A::LOC26)
896 }
897 #[doc = "Location 27"]
898 #[inline(always)]
899 pub fn loc27(self) -> &'a mut W {
900 self.variant(SCLLOC_A::LOC27)
901 }
902 #[doc = "Location 28"]
903 #[inline(always)]
904 pub fn loc28(self) -> &'a mut W {
905 self.variant(SCLLOC_A::LOC28)
906 }
907 #[doc = "Location 29"]
908 #[inline(always)]
909 pub fn loc29(self) -> &'a mut W {
910 self.variant(SCLLOC_A::LOC29)
911 }
912 #[doc = "Location 30"]
913 #[inline(always)]
914 pub fn loc30(self) -> &'a mut W {
915 self.variant(SCLLOC_A::LOC30)
916 }
917 #[doc = "Location 31"]
918 #[inline(always)]
919 pub fn loc31(self) -> &'a mut W {
920 self.variant(SCLLOC_A::LOC31)
921 }
922}
923impl R {
924 #[doc = "Bits 0:5 - I/O Location"]
925 #[inline(always)]
926 pub fn sdaloc(&self) -> SDALOC_R {
927 SDALOC_R::new((self.bits & 0x3f) as u8)
928 }
929 #[doc = "Bits 8:13 - I/O Location"]
930 #[inline(always)]
931 pub fn sclloc(&self) -> SCLLOC_R {
932 SCLLOC_R::new(((self.bits >> 8) & 0x3f) as u8)
933 }
934}
935impl W {
936 #[doc = "Bits 0:5 - I/O Location"]
937 #[inline(always)]
938 #[must_use]
939 pub fn sdaloc(&mut self) -> SDALOC_W<0> {
940 SDALOC_W::new(self)
941 }
942 #[doc = "Bits 8:13 - I/O Location"]
943 #[inline(always)]
944 #[must_use]
945 pub fn sclloc(&mut self) -> SCLLOC_W<8> {
946 SCLLOC_W::new(self)
947 }
948 #[doc = "Writes raw bits to the register."]
949 #[inline(always)]
950 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
951 self.0.bits(bits);
952 self
953 }
954}
955#[doc = "I/O Routing Location Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [routeloc0](index.html) module"]
956pub struct ROUTELOC0_SPEC;
957impl crate::RegisterSpec for ROUTELOC0_SPEC {
958 type Ux = u32;
959}
960#[doc = "`read()` method returns [routeloc0::R](R) reader structure"]
961impl crate::Readable for ROUTELOC0_SPEC {
962 type Reader = R;
963}
964#[doc = "`write(|w| ..)` method takes [routeloc0::W](W) writer structure"]
965impl crate::Writable for ROUTELOC0_SPEC {
966 type Writer = W;
967 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
968 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
969}
970#[doc = "`reset()` method sets ROUTELOC0 to value 0"]
971impl crate::Resettable for ROUTELOC0_SPEC {
972 const RESET_VALUE: Self::Ux = 0;
973}